I’ve long had an alias in my ~/.bash_profile called console. It simply tailed the system log with ‘alias console=‘tail –f /var/log/system.log’.

Bam

I decided to amp it up a little for added convenience. The function below allows me to add additional arguments which are translated into a regular expression for filtering the log output. Arguments, separated by spaces on the command line, are joined into a regular expression as OR matches. You can specify as many as you like to track each as a keyword. It’s case insensitive and you can use basic regular expression syntax in each parameter. Examples:

$ console byword

$ console usbmuxd servermgrd

$ console mark(ed|y) multimarkdown composer

console with no arguments will still just tail the log with no filter.

The function

Just stick this in your ~/.bash_profile file, run . ~/.bash_profile and try it out.

function console () {
  if [[ $# > 0 ]]; then
    query=$(echo "$*"|tr -s ' ' '|')
    tail -f /var/log/system.log|grep -i --color=auto -E "$query"
  else
    tail -f /var/log/system.log
  fi
}

If you want to track more than just the system.log file, you can just add additional filenames, separated by a space, after system.log for each tail command in the function.

There, that was handy.

Related posts:

1. fk: a useful bash function
2. oft: Bash function for opening a specific filetype
3. A Bash function for Markdown bloggers

Originally posted on BrettTerpstra.com at A simple but handy Bash function: console

Yesterday at 5:30pm, this little project was working fine with about eight lines of code. Then I had an idea or two, and by morning it was 160 lines of code. It definitely got out of hand, but I rather like the final product. The bulk of the script is straight bash and UN*X commands, but I shelled a lot of the more complex string handling out to Ruby. I’m too lazy to deal with awk and sed past a certain point.

Feel free to skip to the na GitHub repo, peek at the readme.md file and start playing. I welcome any revisions/iterations of this, so feel free to fork and let me know what you do with it!

Meet “na”

na is a bash function designed to make it easy to see what your next actions are for any project, right from the command line. It works with TaskPaper-format files (but any plain text format will do), looking for @na tags (or whatever you specify) in todo files in your current folder. It can also auto-display next actions when you enter a project directory, automatically locating any todo files and listing their next actions when you cd to the project (optionally recursive).

Features

You can list next actions in files in the current directory by typing na. By default, na looks for “.taskpaper” files and extracts items tagged “@na” and not “@done”. All of these can be changed in the configuration.

Easy matching

na features intelligent project matching. Every time it locates a todo file, it adds the project to the database. Once a project is recorded, you can list its actions by using any portion of the parent directories names. If your project is in “~/Sites/dev/markedapp,” you could quickly list its next actions by typing na dev mark. It will always look for the shortest match.

Recursion

na can also recurse subdirectories to find all todo files in child folders as well. Use the -r switch to do a recursive search on the current directory. na -r with no arguments will recurse from your current location, looking for todo files in all subdirectories. Maximum depth for recursion can be controlled in the config (default is 4). na -r can take a path or project title fragments as arguments as well, and will recurse from the matched directory. A configuration option allows you to have the auto-display recurse by default.

Adding todos

You can also quickly add todo items from the command line with the -a switch. The script will look for a file in the current directory called todo.taskpaper (or whatever extension you’ve set). If found, it will try to locate an “Inbox:” project, or create one if it doesn’t exist. Any arguments after -a will be combined to create a new task in TaskPaper format. They will automatically be assigned as next actions (tagged “@na”) and will show up when na lists the tasks for the project.

More details and usage examples (as well as the download) on the GitHub page.

Related posts:

1. Totally TaskPaper
2. Quick Tip: throttling parallel batch processes in Terminal
3. Quick Link: Terminal navigation utilities

Originally posted on BrettTerpstra.com at na: per-project todos in Terminal

I’ve been using Jon Stovell’s quit script to stop running applications with various save options as part of tweaking a safer universal computing setup with Dropbox. For various reasons I found myself wanting to autocomplete application names, but only ones that were currently running. This technique could be used for any command line tool that runs on running, windowed applications. This version doesn’t do anything for faceless processes, but I’ll show you that in a minute.

A short version to start with. You can run a long one-liner in .bash_profile to return an array of running apps using osascript (AppleScript) and pass it to complete with the -W parameter to accept the variable instead of a function:

APP_COMPLETE=( $( echo "$(osascript -e "set AppleScript's text item delimiters to \"\n\"" -e "tell application \"System Events\" to return (displayed name of every application process whose (background only is false and displayed name is not \"Finder\")) as text" 2>/dev/null)"|sed -e 's/ /\\ /g' ) )

complete -o default -W "${APP_COMPLETE[*]}" quit

This works but isn’t case insensitive, and I’m never satisfied until things are as lazy as possible.

Case-insensitive completion of running app names

The script below is in ~/.app_completions along with my app name completion script for launching (as mentioned in the Bash version of my Get an App’s Icon series). You could just as easily add it to your .bash_profile, but it’s easier for me to keep track of if it’s external.

In .app_completions is this function and complete command:

_complete_running_apps ()
{
  local cur prev 
  local LC_ALL='C'
 
  COMPREPLY=()
  cur=${COMP_WORDS[COMP_CWORD]}
  prev=${COMP_WORDS[COMP_CWORD-1]}
 
  # do not attempt completion if we're specifying an option
  [[ "$cur" == -* ]] && return 0
 
  # Escape dots in paths for grep 
  cur=${cur//\./\\\.}
 
  local IFS="
"
  COMPREPLY=( $( echo "$(osascript -e "set AppleScript's text item delimiters to \"\n\"" -e "tell application \"System Events\" to return (displayed name of every application process whose (background only is false and displayed name is not \"Finder\")) as text" 2>/dev/null)"|grep -i "^$cur" | sed -e 's/ /\\ /g' ) )
 
  return 0
}
 
complete -o bashdefault -o default -o nospace -F _complete_running_apps quit 2>/dev/null || complete -o default -o nospace -F _complete_running_apps quit

It starts start by setting up a few variables to read what the completion command provides as partial text and preceding words. Then it runs the same AppleScript¹ from before, except that by running it through a function we’re taking control of the matching process. Thus, we can use grep -i for case-insensitive matching. We set $COMPREPLY to the result and it’s read in by the auto-complete on the command line.

In the complete command at the end, note that it’s only currently setting up completion for the quit command. Just change quit to something else if you’re using it for something else.

Now, just add a line to .bash_profile to read in the script on login:

source ~/.app_completions

Bonus: kill ‘em all.

You can also do something similar with all running processes, handy for commands like killall. This could also be easily converted to a one-liner like the first script above, but just for the sake of laziness:

_complete_running_processes ()
{
    local cur prev 
    local LC_ALL='C'
 
    COMPREPLY=()
    cur=${COMP_WORDS[COMP_CWORD]}
    prev=${COMP_WORDS[COMP_CWORD-1]}
 
    # do not attempt completion if we're specifying an option
    [[ "$cur" == -* ]] && return 0
 
    # Escape dots in paths for grep
    cur=${cur//\./\\\.}
 
    local IFS="
"
    COMPREPLY=( $(ps axc|awk '{ print $5 }'|sort -u|grep -v "^[\-\(]"|grep -i "^$cur") )
 
    return 0
}
 
complete -o bashdefault -o default -o nospace -F _complete_running_processes killall 2>/dev/null || complete -o default -o nospace -F _complete_running_processes killall

The ps axc reports all running processes with just their executable name. The awk after it grabs the executable names from each line. They’re passed as a list to sort -u which removes duplicates and sorts them in alphabetical order. The first grep removes processes beginning with “(“ or “-” so we can exclude private and terminal commands. There are still plenty of lines autocompleting that you really don’t want to kill, but hey, the command line can be a dangerous place. The last grep does our case-insensitive match for anything that begins with the partial string that we’re completing off of.

So that’s my lunch break. It will ease my hunger pains if someone else finds any use for this. Be sure to let me know!

Related posts:

1. fk: a useful bash function
2. Duplicating Safari browsing sessions between Macs
3. Quick Tip: some .inputrc fun

Originally posted on BrettTerpstra.com at Bash auto-complete for running applications

I was playing around with some readline options this morning, after reading this post on Reddit Commandline. A few of them wouldn’t work for me, so I did some research into the version of Bash that comes with OS X.

Specifically, I wanted to get menu-complete-backward to work in my ~/.inputrc file. menu-complete is a cool feature where you bind a key combination and typing it cycles through available completions. It follows, then, that menu-complete-backward would cycle in the reverse order. It turns out you need a special escape sequence to pull this off on OS X.

Say you want to bind the Tab key to cycle completions one at a time instead of listing them all and requiring you to type characters until there’s only one match. In your .inputrc you would include:

TAB: menu-complete

Binding Shift-Tab to go backward is a little tricker:

"\e[Z": "\e-1\C-i"

The above is working perfectly for me in iTerm2 on GNU Bash 3.2.48(1)-release-(x86_64-apple-darwin11). It will take a few days to decide if I prefer this completion to the normal Tab-complete behavior or whether I want to bind this to a secondary key combination. Either way, it’s handy info to have.

While I’m on the subject, I was playing around with binding commands a while ago and added a couple to my .inputrc which I’ve found helpful. The following will bind Option-z to run cd - followed by ls, returning you to the previous directory in your stack and doing a file listing in one keystroke:

"\ez": 'cd -\015ls\015'

The \015 in the command is the return key, so it’s entering cd -, executing with return, then repeating with ls. You could add any parameters you want (ls -aF) if you don’t already have it aliased in your .bash_profile.

The next one binds Option-x to cd to the folder that was the last argument in my previous command. If I run cp myfile.txt ~/Desktop/, then hitting Option-X will take me to ~/Desktop/ and list its contents:

"\ex": 'cd !$\015ls\015'

Just some Terminal fun… to be clear, all of the above commands would go into the .inputrc file in your home folder. Create it if it doesn’t exist, and be sure to restart your bash shell before trying them out.

Related posts:

1. Quick Tip: repeat Cocoa text actions, Emacs/Vim style
2. Quick Tip: This command line trick is tops
3. A quick TextMate KeyBindings tip

Originally posted on BrettTerpstra.com at Quick Tip: some .inputrc fun

My most obvious use case is Xcode projects, where I may have dozens (and dozens) of files, but there’s only one .xcodeproj file (folder). I don’t always know the name of the project in the folder, but if I run oft xco it will open it without my having to search. If there is more than one result, it gives you a numeric menu to select the file you want to open. You can cancel, select a single file or “Open ALL” from that menu. If you run oft with no arguments, it will read a (partial) extension from a prompt.

This is a script born of laziness (so many good ones are, though). You can accomplish the same with an ls *.ext, spot the file and open filename.ext. This is just faster and better for me when I’m working with less-than-optimal amounts of sleep.

# Open filetype
# Finds every file in folder whose extension starts with the first parameter passed
# if more than one file of given type is found, it offers a menu
oft () {
  if [[ $# == 0 ]]; then
    echo -n "Enter an extension or partial extension: "
    read extension
  fi
  if [[ $# > 1 ]]; then
    echo "Usage: oft [(partial) file extension]"
    return
  fi
  extension=$1
 
  ls *.*$extension* > /dev/null
  if [[ $? == 1 ]]; then
    echo "No files matching \"$extension\" found."
    return
  fi
  declare -a fileList=( *\.*$extension* )
 
  if [[ ${#fileList[*]} -gt 1 ]]; then
    IFS=$'\n'
    PS3='Open which file? '
    select OPT in "Cancel" ${fileList[*]} "Open ALL"; do
      if [ $OPT == "Open ALL" ]; then
        read -n1 -p "Open all matching files? (y/N): "
        [[ $REPLY = [Yy] ]] && $(/usr/bin/open ${fileList[*]})
      elif [ $OPT != "Cancel" ]; then
        $(/usr/bin/open "$OPT")
      fi
      unset IFS
      break
    done
  else
    $(/usr/bin/open "${fileList[0]}")
  fi
}

Related posts:

1. A Bash function for Markdown bloggers
2. fk: a useful bash function
3. fk: redux

Originally posted on BrettTerpstra.com at oft: Bash function for opening a specific filetype

By default, it looks in a Dropbox “Writing” folder, but you can adjust that to restrict to any folder at the top of the script. You can also set your edit command there (mate, mvim, vim, etc.). Then it takes all arguments and uses them as a Spotlight search, restricted to your writing folder and the Markdown filetype, and offers you a quick menu of matches. Selecting a match opens the file with your preferred editor. If there’s only one match, it’s opened automatically.

It’s written as a function to be included in your .bash_profile (or sourced from there). If you want to run it as a shell script, just remove the edmd () { at the top and the closing }, put it in your path and run chmod a+x filename.

Once it’s installed you can just type edmd keyword to find posts and drafts related to keyword. You can use multiple words (no quotes required) and prefixes like “keyword:” or “tag:”, just like a Spotlight query.

# Edit Markdown File from Writing directory
# Finds Markdown files matching a Spotlight-style search query
# If there's more than one, you get a menu
edmd () {
  WRITINGDIR="~/Dropbox/Writing"
  EDITCMD="mate"
  filelist=$(mdfind -onlyin "$WRITINGDIR" "($@) AND kind:markdown")
  listlength=$(mdfind -onlyin "$WRITINGDIR" -count "($@) AND kind:markdown")
  if [[ $listlength > 0 ]]; then
    if [[ $listlength == 1 ]]; then
      $EDITCMD $filelist
    else
      IFS=$'\n'
      PS3='Edit which file? (1 to cancel): '
      select OPT in "Cancel" $filelist; do
        if [ $OPT != "Cancel" ]; then
          $EDITCMD $OPT
        fi
        break
      done
    fi
  else
    return 1
  fi
  return 0
}

Related posts:

1. Fixing Spotlight indexing of Markdown content
2. oft: Bash function for opening a specific filetype
3. fk: a useful bash function

Originally posted on BrettTerpstra.com at A Bash function for Markdown bloggers

It starts out with mdfind and all of the creative scripting you can do with it. You start finding batches of files with something in common and you do things with them or to them. It sounds genocidal; it’s not. It’s very productive after the initial script setup.

Take, for example, a little script I run to add thumbnails to weblocs I have laying around. It looks something like this:

mdfind -onlyin ~/Dropbox/Sync/Bookmark/ \
'(! ( ((kMDItemOMUserTags == "*donotthumbnail*"cd) \
|| (kOMUserTags == "*donotthumbnail*"cd) ) ) \
&& (kMDItemFSHasCustomIcon = "0") \
&& (kMDItemContentType == "*webloc*"cd))' | while read file; \
do /usr/local/bin/setWeblocThumb "$file" ; done

It’s a one-liner, you’d want to reassemble it to run it (remove the backslashes at the line ends and join them all together), but it uses mdfind to search my shared bookmarks folder for recent items which don’t already have a custom thumbnail, passes them to setWeblocThumb and processes them… one at a time. I know my machine and my bandwidth can handle more than that, but if the list is 50+ long, that’s a lot of processes doing some relatively intensive labor. It would grind my machine to a halt. Yes, I tried it just to be sure.

So I needed a way to throttle the number of simultaneous processes, and I know that someone out there must have long beat me to the solution. There it was: parallel. It’s a script you can download and make executable in your path, and then run it with a few parameters and a batch of files or arguments. It will keep your defined number of processes going until the job is done, but won’t let things get out of hand. You can add nice (man page) in each process if you need more cpu control over the process.

My new command looks like:

mdfind -onlyin /Users/ttscoff/Dropbox/Sync/Bookmark/ \
'(! ( ((kMDItemOMUserTags == "*donotthumbnail*"cd) \
|| (kOMUserTags == "*donotthumbnail*"cd) ) ) \
&& (kMDItemFSHasCustomIcon = "0") \
&& (kMDItemContentType == "*webloc*"cd))'| parallel -j 8 -r "/usr/local/bin/setWeblocThumb"

Seriously, if you’re doing anything in batch you should check Parallel out, or show me an even better one. Parallel made my morning, and by keeping CPU from maxing I actually got through some batches even faster. I’m sure there are other elegant ways of handling this. Let ‘em rip.

Related posts:

1. Geeklet: Top RAM Processes
2. Geeklet: Top CPU processes
3. A Bash function for Markdown bloggers

Originally posted on BrettTerpstra.com at Quick Tip: throttling parallel batch processes in Terminal

So, I’m toying with that this morning and I get a sudden urge to be able to make a Skype phone call from the command line. I added a –p flag to aboo which only returns entries which have a phone number. A little awk on the output, and you can get a menu of people to send straight to a function that can call them with Skype. I’ll skip the middle part for now, but here’s a bash function for dialing a number. It accepts multiple formats of strings and tries to turn it into a standardized format for Skype (+15554321111). Usage: skype 5555551111 or skype "(555) 555 5124" (it will strip the extra characters, makes it easier to paste and dial quickly).

skype () {
  number=`echo $1|sed 's/[\(\)\+ \-]//g'|sed 's/^1//'|sed 's/^/+1/'`
  osascript -e "tell application \"Skype\" to send command \"CALL $number\" script name \"CLIDIALER\""
}

I normally make most of my Skype calls from LaunchBar, but this will come in handy every once in a while when I’m already working in Terminal. Thought it might be handy for someone else, too.

Related posts:

1. Answer Skype with a hotkey
2. SMS from the command line with Google Voice
3. Quick Tip: This command line trick is tops

Originally posted on BrettTerpstra.com at Address Book search and Skype from the command line

HTML5 video, if you’re not familiar, provides a means to supply modern browsers with high-quality video without using Flash. It works across iOS devices beautifully, and the markup is highly semantic. The problem is that every browser has chosen a different format to promote, and using HTML5 video effectively means providing the same video in three formats (OGV, MP4, WEBM). Then, you need to code in a Flash fallback for older browsers. This would all be fine if my usual video conversion tools had a multiple-encode feature. They don’t. The only one that comes close is Evom, which has an HTML5 preset to encode OGV and MP4 at the same time, but the OGV files won’t play in Firefox and it can’t do WEBM at all right now.

So, taking matters into my own hands…

The workflow

Here’s the workflow I’m using now:

1. Export a screencast as an MP4 file to a bucket folder
2. Hazel detects a new MP4 file and runs a shell script on it which:
   1. Creates a new folder based on the file’s base name and moves the file into it
   2. Runs an ffmpeg sequence to create a webm version
   3. Runs an ffmpeg2theora command to create an ogv
   4. Uses ffmpeg to create a poster image from the first frame of the mp4
   5. Uses rsync to put the finished folder on my server
3. I get a growl notification from Hazel that files are converted and uploaded
4. I insert the ungodly-long “shortcode” for the VideoJS plugin using TextExpander into a new WordPress post.

Four steps, and I only have to interact with two of them. The script is pretty hardcoded for my setup, but I moved some of the config up to the top for convenience. You’ll need ffmpeg and ffmpeg2theora installed, both of which are really easy to set up with homebrew. You can probably find binaries, too, but I just used brew for these.

The script

Here’s the script, hope it helps someone else, too:

#!/bin/bash
# html5encode.sh
# Brett Terpstra, 2011 - http://brettterpstra.com/automating-html5-video-encodes
# Requires ffmpeg and ffmpeg2theora
##################
### CONFIG #######
MAXSIZE="960x540"
SSHURL="username@your.webserver.com"
SSHDIR="/www/video/media/"
### END CONFIG ###
 
INPUT=$1
DIRNAME=`dirname "$INPUT"`
FILENAME=`basename "$INPUT"`
BASENAME=${FILENAME%%.*}
 
cd "$DIRNAME"
if [ -d "$BASENAME" ]; then
  # /usr/local/bin/growlnotify -s -i "Terminal.app" -m "Found $FILENAME, but directory $BASENAME already exists. Aborting"
  exit 1
fi
mkdir "$BASENAME"
mv "$FILENAME" "$BASENAME/"
cd "$BASENAME"
 
/usr/local/bin/ffmpeg -pass 1 -passlogfile "$FILENAME" -threads 16  -keyint_min 0 \
-g 250 -skip_threshold 0 -qmin 1 -qmax 51 -i "$FILENAME" -vcodec libvpx -b 614400 \
-s $MAXSIZE -aspect 16:9 -an -y temp.webm
 
/usr/local/bin/ffmpeg -pass 2 -passlogfile "$FILENAME" -threads 16  -keyint_min 0 \
-g 250 -skip_threshold 0 -qmin 1 -qmax 51 -i "$FILENAME" -vcodec libvpx -b 614400 \
-s $MAXSIZE -aspect 16:9 -acodec libvorbis -y "$BASENAME".webm
 
rm temp.webm
rm *.log
 
/usr/local/bin/ffmpeg2theora --videoquality 5 --audioquality 1 --max_size $MAXSIZE "$FILENAME" -o "$BASENAME.ogv"
/usr/local/bin/ffmpeg -i "$FILENAME" -ss 0 -vframes 1 -vcodec mjpeg -f image2 "${BASENAME}Poster.jpg"
cd ..
rsync -v -r -e ssh "`pwd`/$BASENAME" $SSHURL:$SSHDIR

The Hazel rule I’m running simply looks for files in the bucket folder with the .mp4 extension and passes them to the shell script.

Let me know if you have a better way to automate this. Also, let me know if you’ve found a good way to encode h.264 from the command line on a Mac. I haven’t been able to get ffmpeg to compile with x/h.264 support yet, but it was irrelevant as I had to output some format to begin with. Might as well save to the one format I can’t encode properly from a shell script…

Related posts:

1. Automated HTML5 video encoding revisited
2. Quick notes on cross-browser HTML5 video
3. Fog In The Valley

Originally posted on BrettTerpstra.com at Automating HTML5 video encodes

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

Anyway, I had two goals: first, I wanted a basic calculator on the command line with the ability to optionally output a result with no newlines, so it would be easy to substitute within another command or pass to pbcopy. Basic inline math. Then, as a side project to this side project, I wanted a tally-keeper that would allow me to just keep inputting numbers until I told it to stop, and then just add them all up. Nothing brilliant, and I had simple answers for both problems in about 10 minutes.

Built-in evaluators in Bash kind of stink, though, and they need special formatting and escaping to deal with floats and accommodate basic symbols. bc seemed like the logical answer to that, and that’s what I’m using right now. I picked up a few good tips from the blog post that Allan Odgaard wrote when he was on a similar mission, both from Allan and from the commenters. I love the web.

So here’s what I’ve got for the calculator. It strips any character that’s not grade-school math out and normalizes spaces, which works well for my needs. You can actually just trash the whole second line and pass “$@” to bc if you want to use additional symbols. The second function in this block calls the first and strips newlines, good for integration elsewhere. You can also alias either of these to a question mark for fast access (inspired by Allan) with alias ?="calc" in your .bash_profile. That’s where these functions are likely to go as well. If you want to try them out, paste them into ~/.bash_profile, save it, run source ~/.bash_profile in Terminal and then type calc 3+(5*2) or whatever you like.

function calc() {
  equat=$(echo ${@//[^0-9\.\+\/\*\(\)]/ }| sed 's/[ \t]*//g')
  echo $equat|bc -lq
}
 
## just for fun, ccalc trims the newline 
## and copies the result directly to the clipboard
function ccalc () {
  calc $@|tr -d '\n'|pbcopy
}

Things get tricky if you need to control the number of decimal places you have in the result. You need to pass additional commands to bc, which appears to require some heredoc magic. This works for me (the scale=4 sets it to four decimal places):

function calc2() {
  bc -l << EOF
scale=4
$@
quit
EOF
}

Next up is tally(), a function that does what it says. You can either pass it a list of numbers, or run it and let it go into interactive mode. It will let you type numbers separated by returns, spaces or a combination, as long as there’s a separation. When you press “=” it adds up all of the numbers you’ve entered. I wanted it for when people start giving me numbers and amounts on the phone. And yes, I can do it in LaunchBar (et al), but like I said, sometimes I just get a bug to do it the hard way. The only thing I hate about this implementation is that you can’t use the default mapping of the Backspace key, as everything is interpreted raw. You have to run read in readline mode to avoid this, but that means you can’t use Enter anymore. That’s the kind of thing that makes me spend an hour trying to solve it. This version is my compromise; you can try it with the “-e” argument and see if you prefer backspace to enter. Same installation: paste it, source and run it.

function tally() {
  if [[ $# == 0 ]]; then
    echo "Enter numbers, press = for sum:"
    read -d "="
    input=$REPLY
    echo "================"
  else
    input="$@"
  fi
  sum=0
  for i in $input; do 
    sum=$sum+$i
  done
  echo $sum|bc -l
}

And that, ladies and gentleman, is your dose of stupid Bash tricks for the evening. Good night.

Related posts:

1. oft: Bash function for opening a specific filetype
2. A simple but handy Bash function: console
3. Grabbing a Mac app’s icon: advanced Bash usage

Originally posted on BrettTerpstra.com at Quick calculations in Bash

It uses php’s strtotime function, which does a pretty swell job with simple dates like “next tuesday” or “+12 days”. It’s not very smart, though; you have to give it parameters in a specific order:

td "task name" "natural language date" "note"

Only the first parameter is required, so your task at least has a title. If you have two, it expects that the second is a date of some kind, and anything in the third will be added as a note.

Here’s the code…

function td() {
  if [ $# -lt 1 ]; then return 1;fi
  if [ $# -gt 1 ]; then
    duedate=`php -r "date_default_timezone_set('America/Chicago');echo date('m/d/y',strtotime('$2'));"`
    duedate=",due date:date \"$duedate\""
  fi
  osascript -e "tell application \"Things\"" \
  -e "make new to do at list \"Inbox\" with properties {name:\"$1\",notes:\"$3\"$duedate}" \
  -e "end tell"
}

Just paste it at the end of your ~/.bash_profile and type source ~/.bash_profile to read it in. If you use it, I’d love to hear about it, and if you improve it, let me know what you did differently!

Related posts:

1. OS X Service for natural language dates
2. Natural language dates for TextExpander
3. A simple but handy Bash function: console

Originally posted on BrettTerpstra.com at Things tasks from the command line

It’s a very simple little shell command which uses curl to track down the destination of a shortened url (or any link with a redirect). It works with an assortment of services, including bit.ly, tinyurl.com, ow.ly, etc. It returns the destination address (the original url), and you can pass that on to whatever you like!

Side note: I’ve been working on a little site called JustTheLinks which makes liberal use of url-lengthening. It grabs all of your tweets from your home timeline which contain links, and creates a live-updated list with expanded urls and titles. It uses PHP’s curl to do the trick, so it’s the same concept. It’s “in-progress,” but feel free to check it out at http://justthelinks.com!

Anyway, I decided to update the Quicksilver action and adapt it for some other uses. I’m happy to report that it’s still quite useful as a command line script, a LaunchBar action or a System Service. This post has code for all three, so take your pick!

The curl command in this script has two options specified, –I and –s. –I tells it to fetch only the headers of the requested URI, and the –s tells it to suppress error messages (silent). The result is a short response which contains the location of the redirect, which is piped to awk. We look for the line in the response containing “Location” and print the second field of that line, which is the destination url. Here are a few ways I thought of to put it to use:

Terminal

The first thing I did was whip up a shell script to run from the command line. Just create a text file wherever you keep scripts², or make a new directory somewhere for it. Paste in the code below, and name it something that makes sense to you. I went with follow, because it’s following the redirect path, and expand was taken (and lengthen didn’t seem as much fun to type…). The script looks for a single argument, which would be the shortened url, and if it doesn’t receive one it tries the clipboard. So, if you already have the url in your clipboard, which is a pretty safe bet in this case, you can just run the script with no arguments.

#!/bin/bash

if [ $# -eq 0 ]; then
  curl -Is `pbpaste` | awk '/Location/ { print $2 }'  
else
  curl -Is $1 | awk '/Location/ { print $2 }'
fi

LaunchBar

I heart LaunchBar. Like Quicksilver, you can easily build “actions” for it that act on different types of input. This one just acts on text you paste or send to it, and assumes it’s going to be a shortened URL. After it lengthens it, it just displays the result as large popup text. If you wanted to, you could easily have it open location or whatever, but the whole point is just to see where you’re going, right?

This just goes into ~/Library/Application Support/LaunchBar/Actions as a compiled AppleScript (scpt) file. Open AppleScript Editor and paste in the code below (or just click here to open it automatically in your editor). Save the file to the Actions folder and give it a name you’ll recognize. Mine’s called ‘Expand Shortened URL.scpt’. Clever, I know. Here’s the code:

on handle_string(message)

    tell application "LaunchBar"
        set _res to do shell script "curl -Is " & message & " | awk '/Location/ { print $2 }'"
        display in large type _res
    end tell

end handle_string

Snow Leopard Service

Lastly, here’s a System Service that you can run on selected text in any Cocoa application. I’ve previously posted a Service for shortening urls, so here’s the opposite. This one can actually take a whole block of text and will scan for any and all links in it, attempting to lengthen and replace any shortened urls in the text. Here’s how to build it:

• Open Automator.app
• Select “Service” from the new file menu
• Set “Service receives selected” to “text” in “any application”
• Check the “Replaces selected text” box
• Find the “Run Shell Script” action on the left and drag it into your workflow on the right
• Set the Shell to Ruby (in this case)
• Paste in the code below
• Save the file to the ~/Library/Services folder, named something like “Expand shortened urls in selection” (or something more interesting)

Now, when you select text in any Cocoa application (Safari, Mail, TextEdit, etc.), you’ll be able to find your Service in the Services submenu of either the application menu in the menubar, or in the contextual menu that comes up when you right click (ctrl-click) the selected text. When you run it, it will replace your text with a new version with any shortened urls in it expanded.

#!/usr/bin/env ruby -rjcode -Ku

require 'open-uri'

input = STDIN.read
links = input.scan(/\b((?:https?:\/\/)(?:www\.)?([^\/]+)\/[a-zA-Z0-9]+[^\s`!()\[\]{};:'".,<>?«»“”‘’])/im)
links.each {|link|
  result = %x{curl -Is #{link[0]} | awk '/Location/ { print $2 }'}
  input = input.gsub(/#{link[0]}/,result.strip)
}
print input

How often will you need any of these little experiments? Probably not very often. Most of the time, I’m more than happy to just follow a shortened link and trust that the description it came with will hold true. Every once in a while, though, I come across a link of unknown origin that I’d prefer to run through something like this. Hopefully you’ll be able to find a use for it, too. It’s a cool little snippet.

Related posts:

1. A System Service for to. url shortening
2. LaunchBar actions for url encoding and decoding
3. A better System Service for Evernote clipping — with MultiMarkdown

Originally posted on BrettTerpstra.com at Is your URL too short? Try our system, free!