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

Thanks to a comment from Evaryont on the original SMS from the command line with Google Voice post, a problem that was causing Error 500s in the script has been solved.

Check the original post for the script, and change the line (around line 90)

rnrse = newres.match(/‘_rnr_se’: ‘([^’]+)’/)[1]

to:

rnrse = CGI.escape(newres.match(/‘_rnr_se’: ‘([^’]+)’/)[1])

The CGI escaping should help with the Google’s changes to the _rnr_se variable. Evaryont also notes that the script works great in Arch Linux with Ruby 1.9.2. For 1.9 compatibility (thanks to David for clarification in the comments below), remove the -rjcode from the hashbang on the first line, and add require 'jcode' if RUBY_VERSION < '1.9' below. Have fun!

Related posts:

1. SMS from the command line with Google Voice
2. A System Service for to. url shortening
3. Address Book search and Skype from the command line

Originally posted on BrettTerpstra.com at GVoice command line SMS revisited

I just (accidentally) discovered the command tops while working in Terminal. I’m not seeing many of mentions of it (any) on the web, but it could be too early in the morning for me to form a coherent query. Regardless, I thought I’d give it a mention. The man page is quite complete, and has a succinct explanation of the command: tops - perform in-place substitutions on code.

It’s not just useful for code, though, it makes a great tool for batch modifications to any text file(s). With an easy-to-grok syntax, it does in a few words what I usually do in three or more piped oneliners (grep, awk, sed, etc.). There’s a replacemethod option specifically for replacing Objective-C-style method names, which leads me to believe that this is an OS X-only tool, possibly only part of the Developer Tools. If anyone more familiar with this command has insight, I’d be curious.

Tops can read a script file with rules for search and replace, or take commands as arguments to process changes in a text file instantly. Simple example:

tops replace "Word" with "Markdown" writing.*

All instances of “Word” in all files with the name “writing” were just replaced with “Markdown.” Try it, it’s cool. The options go far beyond my simplistic example, but the more complex options are primarily specific to Objective-C. If this piques your curiosity anyway, spend some time with man tops.

Related posts:

1. Address Book search and Skype from the command line
2. GVoice command line SMS revisited
3. Quick Tip: Extracting Mac App Store reviews as text

Originally posted on BrettTerpstra.com at Quick Tip: This command line trick is tops

Apple has disabled the ability to copy and paste text (or even select it) in the Mac App Store. This is fine for descriptions, you can just view the web preview and get what you need (just right click the icon in the App Store app and choose Copy Link to paste into your browser). You can even get to the first few reviews that way. Marked users have left some insanely nice reviews, though, and I wanted to capture them all (both for marketing and for general warm fuzzies).

First, we need to enable WebKit’s Inspector in the App Store. In case you didn’t know it, the App Stores for both Mac and iOS (iTunes) are just HTML. With the Webkit Inspector loaded, you can dig right into the code.

Quit the App Store application. Run this line in Terminal:

defaults write com.apple.appstore WebKitDeveloperExtras -bool true

Now, (after starting App Store back up) when you right click an element, you’ll get a contextual menu with “Inspect Element.” Go ahead and select it. If you’re not familiar with the Inspector, have a peek around. The main section you need for this, though, is the first one: Elements.

It shows an outline of the DOM (post JavaScript processing) and lets you select any element on the page. You can get to elements quickly by turning on the magnifying glass at the bottom and hovering over elements on the page to highlight them in the Inspector. Note that you can break the inspector out of the main window and into it’s own with the icon in the lower left corner.

For my purposes I wanted all of the html text in the reviews section, so I navigated to the containing element and selected it. Right clicking on the element in the inspector now offers me the ability to “Copy as HTML.” Doing that gives me that whole chunk of HMTL and makes writing up “testimonials” for the new Marked website much, much easier.

If you want to go the extra mile, and I do, you might want to convert all of this markup to something more readable. If you use the Blogsmith Blogging bundle in TextMate, you already have a command (Convert HTML to Markdown) that will turn the HTML chunk into nicely formatted Markdown. You can also use html2text.py, Markdownify for PHP or Pandoc.

A couple of quick regular expression search and replace maneuvers later, I have a list of all of my reviews thus far, with attribution and title. Nice.

Marked 1.2 is looking great, by the way, and should be in your hands faster than you can terrace a backyard, assuming you’re in moderate shape and have some evening and weekend time available. Maybe faster than that. It would take you 2–3 weeks, right?

Related posts:

1. Quick Tip: fixing the “other account” Mac App Store issue
2. Marked is on the Mac App Store
3. MultiMarkdown Composer hits the App Store

Originally posted on BrettTerpstra.com at Quick Tip: Extracting Mac App Store reviews as text

I’ve been trying to get Option-arrow keys to move by word in iTerm2. I figured out a solution, but it’s weird. If anyone has an explanation or a better way to do this, let me know.

First, I had to edit my ~/.inputrc file and add these lines:

"\e[1;5C": forward-word
"\e[1;5D": backward-word

Then I had to set up in iTerm2 preferences–under Profiles->Keys–the options for both key combinations:

• Add a hotkey with the plus symbol at the bottom of the hotkey list
• Set the keyboard shortcut by pressing Option-left or Option-right
• Set the action to “Send Escape Sequence”
• Set the Esc+ field to:
  • [1;5C (Option-Right)
  • [1;5D (Option-Left)

With these in place both work swimmingly. I don’t know why I had to do both parts, though…

Related posts:

1. New text navigation KeyBindings
2. KeyBinding madness
3. Filesystem navigation with TextExpander

Originally posted on BrettTerpstra.com at Option-arrow navigation in iTerm2

I found a couple of solutions this morning. There’s a package called cdargs which lets you bookmark folders with short names, autocomplete bookmarks, use bookmarks in copy and move actions and list and visually select from all of your bookmarks. I had some conflicts on my system that prevented me from using it, though, so I went with a simpler solution: bashmarks by Huy Nguyen.

Bashmarks lets me do most of what cdargs can do, but with a few less frills (and no conflicts with my setup). I can bookmark the css folder in my blog development folder btcss, and one in a client folder as clientcss and be able to quickly jump to the right one. Bashmarks provides autocomplete, too, so typing g bt[tab] gets me to btcss in a jiffy.

On the way, I also discovered a package called z, which bills itself as “the new j” (in reference to autojump). It takes multiple arguments and uses them to more specifically match the folder you want to jump to. So, if I have a css folder in /brettterpstra/ and in /myclientsite/, I could type z brett css or z client css to distinguish between them. I haven’t bothered with replacing autojump in my config files yet, but this looks promising.

Related posts:

1. Quick Tip: throttling parallel batch processes in Terminal
2. Quick Link: historio.us
3. Filesystem navigation with TextExpander

Originally posted on BrettTerpstra.com at Quick Link: Terminal navigation utilities

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

What it does

The script is specifically designed to take an MPEG-4, H.264 file, move it to a new folder based on the filename, create WEBM and OGV versions of it in the new folder, and upload the whole folder to a server using rsync. SSH information and target directories are specified in the config at the top of the script. At the end, it takes what it knows about the files and filenames and creates a TextMate Markdown blog template, inserts the video shortcode for the VideoJS WordPress plugin (which is common syntax for other plugins as well) and opens it for editing in TextMate. The rsync command really needs keyless SSH login for this to be considered fully-automated.

If you run this script with Hazel, you can just render an H.264 video (.mov files that pass the H.264 test¹ will automatically be renamed to .mp4) to that folder from your screen-recording application of choice, sit back for a few minutes (or start writing the post) and wait for the pre-populated TextMate blog post to pop open. Then type or paste your text in, hit Control-Command-P (assuming you’re set up for TextMate->WordPress blogging) and your video is posted.

Improvements

The first thing that happened in this rewrite was a major simplification of the WEBM encoding process, which now only takes a third of the time it did before and the files are not significantly larger in most cases. They may even look better. The old command involved two passes, one of them turning out to be unnecessary; ffmpeg is smarter than I thought. The new command (using the variables from the script) is just /usr/local/bin/ffmpeg -i "$FILENAME" -b 614400 -s $MAXSIZE -aspect 16:9 "$BASENAME".webm.

I also added better logging, optional progress reports with Growl, batch file handling and a few other refinements. The logging, if enabled in the config at the top, will output information including processing time for each file and total processing time to STDOUT (command line) and to the system log where you can watch it from Console. If you enable growl notifications, the messages at the beginning and end of each conversion will be “growled” on your screen.

Using the script

You’ll need a couple of additional utilities to do the conversions.

Requirements

To run the script and do the encoding, you’ll need ffmpeg and ffmpeg2theora. You can install ffmpeg from Homebrew (brew install ffmpeg) quite easily, if you’re set up for that. You can also pull the binary out of ffmpegX with a few simple steps. You can, of course, build your own if you have the developer tools installed.

ffmpeg2theora (needed for OGV conversion) no longer appears to be available from brew, but there are OS X binaries (and source) available for download.

The script is below. You’ll want to modify the information in the configuration section at the top, and modify the template output at the bottom to suit your needs. Anything between <<-POSTTEMPLATE and POSTTEMPLATE is freeform text that you can edit in any way you like, including the use of $variables. If you’d rather do something such as copy a shortcode to your clipboard and show a Growl message, just use pbcopy and growlnotify. You could also just comment out the template part and let Hazel tell you when it’s done, if you want to handle things more manually. I’ll let you work out the details on that.

Command line usage

To use the script from the command line, save it as “html5encode.sh” somewhere in your path, change to its parent folder in Terminal and run chmod a+x html5encode.sh. The you can run it on any h.264 .mov or .mp4 file and it will handle the rest. It also handles batches, so you can specify multiple targets or use *.mp4 to run it on all .mp4 files in a folder. It will process them one by one, creating new folders for each.

Hazel

If you want to run it with Hazel, you can follow the same procedure and set up a rule that runs a shell script when a .mov or .mp4 is detected in a watch folder. The script can then be run as a command or be pasted in its entirety into the Hazel script editor within the rule.

You should be able to pull off using this with OS X Folder Actions, as well, but I haven’t played with that yet.

Bonus tip: If you name your original .mov or .mp4 file with a CamelCased name, it will break apart the filename and create the title of your post based on it. Not an essential feature, but kind of nifty. Well, I think so anyway.

The script

View Raw | Download

#!/bin/bash
#################################################################
### html5encode.sh by Brett Terpstra and Mike Rose
### Published 05/01/2011
### Freely distributed, modifications welcomed (with attribution)
#################################################################
### Configuration ###############################################
#################################################################
MAXSIZE="960x540"
DISPLAYWIDTH="600"
DISPLAYHEIGHT="338"
SSHURL="username@ssh.host.name"
SSHDIR="/server/folder/target/for/rsync/"
WEBDIR="/front-end/url/path/video/" # used for blog template
LOGGING=true # send status messages and times to STDOUT and syslog
GROWLLOG=false # duplicate messages to growl, if installed
##################################################################
### END Configuration ############################################
##################################################################
 
# function to handle logging (if enabled) to STDOUT and STDERR 
# as well as Growl (if enabled)
function logit() {
  if $LOGGING ; then
    logger -st "HTML5 Encoder" "$1"
    if $GROWLLOG ; then
      /usr/local/bin/growlnotify -t "HTML5 Encoder" -a "Terminal" -m "$1"
    fi
  fi
}
 
# Count the inputs for log message
if [[ $# -gt 1 ]]; then
  logit "Starting batch conversion."
  maintimer1=`date '+%s'`
else
  logit "Starting HTML5 Encoder"
fi
 
# Loop through each passed file
for file in "$@"; do
  timer1=`date '+%s'`
  INPUT=$file
  # Check that input file is H.264
  isH264=`mdls -raw -name kMDItemCodecs $INPUT|grep H.264`
 
  if [ !$isH264 ] ; then
    logit "$INPUT is not h.264"
    continue
  fi
 
  DIRNAME=`dirname "$INPUT"`
  FILENAME=`basename "$INPUT"`
  BASENAME=${FILENAME%%.*}
  logit "Conversion of $FILENAME started on `date '+%D'` at `date '+%r'`"
  bytesize=`stat -f '%z' $FILENAME`
  filesize=`echo "scale = 2 ; $bytesize/1048576"|bc -lq`
  cd "$DIRNAME"
  if [ -d "$BASENAME" ]; then
    logit "Found $FILENAME, but directory $BASENAME already exists. Aborting"
    continue
  fi
  mkdir "$BASENAME"
  mv "$FILENAME" "$BASENAME/"
  cd "$BASENAME"
  if [[ ${FILENAME#*.} -eq "mov" ]]; then mv $FILENAME ${BASENAME}.mp4; fi  
  FILENAME=${BASENAME}.mp4
  /usr/local/bin/ffmpeg -i "$FILENAME" -b 614400 -s $MAXSIZE -aspect 16:9 "$BASENAME".webm
  logit "Completed webm conversion"
  /usr/local/bin/ffmpeg2theora --videoquality 5 --audioquality 1 --max_size $MAXSIZE "$FILENAME" -o "$BASENAME.ogv"
  logit "Completed ogv conversion"
  /usr/local/bin/ffmpeg -i "$FILENAME" -ss 0 -vframes 1 -vcodec mjpeg -f image2 "${BASENAME}Poster.jpg"
  logit "Created poster image"
 
  # Create a title from camelcased filename
  TITLE=`echo "$BASENAME"|sed 's/\([A-Z][^A-Z]*\)/& /g'|sed 's/ $//'`
  SERVER=`echo "$SSHURL"|sed 's/^.*\@//'`
  logit "Uploading to $SERVER..."
  cd ..
  rsync -v -r -e ssh "`pwd`/$BASENAME" $SSHURL:$SSHDIR
  logit "Finished Uploading"
  # remove trailing slash from $WEBDIR
  WEBDIR=`echo "$WEBDIR"|sed 's/\/$//'`
  cat > "$BASENAME/$BASENAME.blog.markdown" <<-POSTTEMPLATE
Type: Blog Post (Markdown)
Blog: BlogsmithVideo
Title: $TITLE
Keywords: 
Status: draft
Pings: On
Comments: On
Category: Tutorial
 
Synopsis
 
[video mp4="$WEBDIR/$BASENAME/$BASENAME.mp4" ogg="$WEBDIR/$BASENAME/$BASENAME.ogv" webm="$WEBDIR/$BASENAME/$BASENAME.webm" poster="$WEBDIR/$BASENAME/${BASENAME}Poster.jpg" preload="true" width="$DISPLAYWIDTH" height="$DISPLAYHEIGHT"]
 
<!--more-->
Transcript
 
POSTTEMPLATE
 
  open "$BASENAME/$BASENAME.blog.markdown" -a "TextMate.app"
  timer2=`date '+%s'`
  time=`echo "scale=2 ; ($timer2-$timer1)/60"|bc -lq`
  logit "Conversion of $FILENAME complete"
  logit "It took $time minutes to process a ${filesize}M MP4 to webm and ogv and upload to `echo "$SSHURL"|sed 's/^.*\@//'`."
done
if [[ $# -gt 1 ]]; then
  maintimer2=`date '+%s'`
  total=`echo "scale=2 ; ($maintimer2-$maintimer1)/60"|bc -lq`
  logit "Batch conversion complete, total time $total minutes."
fi

Hopefully this will make a few people’s lives easier. Mike and I have battle tested it and it seems to be a pretty great fit for our needs. If you modify it for your own needs, please share (with credit) so that it can become as well-rounded as possible!

Related posts:

1. Automating HTML5 video encodes
2. Seriously easy HTML5 video encoding
3. oft: Bash function for opening a specific filetype

Originally posted on BrettTerpstra.com at Automated HTML5 video encoding revisited

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

The code

To use it, copy the code below into a text file, save it as voicesms.rb (or download it directly using the link at the top of the code), and run chmod a+x voicesms.rb from the command line to make it executable.

#!/usr/bin/env ruby -rjcode -Ku
 
require 'net/http'
require 'net/https'
require 'open-uri'
require 'cgi'
require 'optparse'
 
ACCOUNT = '' # Set to Google Voice account email for default account
PASSWORD = '' # Set to Google Voice account password for default account
NUMBERS = ['+1555444333','+1555444222'] # Set one or more numbers for default destination(s)
 
options = {}
optparse = OptionParser.new do|opts|
  opts.banner = "Usage: voicesms.rb -n +15554443333[,+15554442222] -m \"Message to send\" [-u Username:Password]"
 
  options[:numbers] = NUMBERS
  opts.on( '-n', '--numbers NUM[,NUM]', 'Phone numbers to SMS (separate multiples with comma)' ) do|numbers|
    options[:numbers] = numbers.split(',')
  end
 
  options[:message] = false
  opts.on( '-m', '--message MESSAGE', 'Message to send' ) do|msg|
    options[:message] = msg
  end
 
   options[:username] = ACCOUNT
   options[:password] = PASSWORD
   opts.on( '-u', '--user USERNAME:PASSWORD', 'Google Voice username and password' ) do|creds|
     parts = creds.split(':')
     options[:username] = parts[0]
     options[:password] = parts[1]
   end
 
  opts.on( '-h', '--help', 'Display this screen' ) do
    puts opts
    exit
  end
end
 
optparse.parse!
 
unless options[:message]
  puts "Message required. Use -m \"MESSAGE\"."
  puts "Enter `voicesms.rb -h` for help."
  exit
end
 
def postit(uri_str, data, header = nil, limit = 3)
    raise ArgumentError, 'HTTP redirect too deep' if limit == 0
    url = URI.parse(uri_str)
    http = Net::HTTP.new(url.host,443)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    response,content = http.post(url.path,data,header)
    case response
      when Net::HTTPSuccess     then content
      when Net::HTTPRedirection then postit(response['location'],data,header, limit - 1)
      else
        puts response.inspect
        response.error!
    end
end
 
def getit(uri_str, header, limit = 3)
    raise ArgumentError, 'HTTP redirect too deep' if limit == 0
    url = URI.parse(uri_str)
    http = Net::HTTP.new(url.host,url.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    response,content = http.get(url.path,header)
    case response
      when Net::HTTPSuccess     then content
      when Net::HTTPRedirection then getit(response['location'],header, limit - 1)
      else
        response.error!
    end
end
 
data = "accountType=GOOGLE&Email=#{options[:username]}&Passwd=#{options[:password]}&service=grandcentral&source=brettterpstra-CLISMS-2.0"
res = postit('https://www.google.com/accounts/ClientLogin',data)
if res
  authcode = res.match(/Auth=(.+)/)[1]
  header = {'Authorization' => "GoogleLogin auth=#{authcode.strip}",'Content-Length' => '0'}
  newres = getit('https://www.google.com/voice',header)
  if newres
    rnrse = newres.match(/'_rnr_se': '([^']+)'/)[1]
    options[:numbers].each {|num|
      data = "_rnr_se=#{rnrse}&phoneNumber=#{num.strip}&text=#{CGI.escape(options[:message])}&id="
      finalres = postit('https://www.google.com/voice/sms/send/',data,header)
      if finalres["ok"]
        puts "Message sent to #{num}"
      else
        puts "Error sending to #{num}"
      end
    }
  else
    newres.error!
  end
else
  res.error!
end

Usage

You can set default account name, password and send-to numbers at the top of the script. These can be overridden by command line options at runtime. The standard syntax is:

voicesms.rb -n +15552525543,+15554342221 -m "The message to send" -u GVoiceUsername:GVoicePassword

Parameters can be in any order. The –n parameter takes one or more phone numbers in international format (+XX country code at the beginning, +1 for US numbers), separated by commas (no spaces).

The –m option (message) is required and can’t be set by default in the script. Just use –m “and a quoted message” and it will handle the rest.

–u defines a username/password combination for Google Voice. It’s probably most convenient to set these at the top of the script and ignore this parameter, but the option is there.

–h will provide the help information.

Aliasing

The point of the script is to let me automate SMS messages from my system, so its primary invocation will be from other scripts. However, it will function just fine as a command line texting utility, in which case you’d probably want to alias the core functions in your .bash_profile. Set your default username and password in the script, and maybe a default destination number. If you want to send to a different numbers, you might want to make several aliases which include different -n # parameters, one for each destination. The alias will look something like:

alias sms="~/scripts/voicesms.rb -m"

Or, maybe:

alias smsjohn="~/scripts/voicesms.rb -n +15554443333 -m"

Get it? Then you can just type smsjohn "And your message" to send the message straight to John. Whoever that is.

What it does

It’s pretty simple, just a series of POST and GET requests to the Google API. It uses Google’s client authentication to get an initial auth code. Then it uses the auth code to get an auth token. Then, it posts your information to the API with the proper headers (the auth token) to complete the call. All of your data is sent securely over SSL (https) connections.

Have fun!

Related posts:

1. Single-keystroke Instapaper in Google Reader
2. GVoice command line SMS revisited
3. GReader Instapaper 0.2

Originally posted on BrettTerpstra.com at SMS from the command line with Google Voice

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!

I know, it’s stupid for two reasons: first, it’s just not that big a deal, and second, I could just use the Emacs keybindings (^F,^B,^P,^N, etc.). Well, to that I say “phooey” on both counts. It is a big deal; I’ve probably lost hours of my life to that motion. As to the latter, I didn’t grow up on Emacs, and those shortcuts have just never nestled into my muscle memory. In related news, I already have some of those keys bound elsewhere.

I used to use KeyRemap4Macbook to map control-j,i,l and m to the cursor keys, but haven’t installed it since my last clean wipe (just in case it was part of the reason I had to do the clean wipe to begin with). I missed that convenience, though, so after 15 minutes of Googling, here’s the answer…

Allan Odgaard, creator of TextMate, offers the beginning of the solution on the TextMate blog. I found a little more detailed information around the net, too. Basically, you can add or edit a file called DefaultKeyBinding.dict in ~/Library/KeyBindings/ to add the keystrokes to all Cocoa applications. Mine looks like this now:

{
  "^j" = "moveBackward:";
  "^l" = "moveForward:";
  "^m" = "moveDown:";
  "^i" = "moveUp:";
  "^E" = "\"editInTextMate:\"";
}

The first part of each pair is the keystroke, and the second part is the action. To find a list of the available actions, I just looked at /System/Library/Frameworks/AppKit.framework/Resources/StandardKeyBinding.dict, which has all of the default OS X keybindings in it. You’ll need Property List Editor to view the file in its default state. To view the file in a text editor, you have to convert it to an XML (old school and plain text) plist. If you’re curious, copy the file to your Desktop and, in Terminal, run plutil -convert xml1 ~/Desktop/StandardKeyBinding.dict.

After editing DefaultKeyBinding.dict and restarting your Cocoa apps, your new keyboard shortcuts will be available. That’s when I found the next problem. TextMate has ^J mapped to “Reformat and Justify” under the Text menu. I never, ever use that command, so that was just annoying. I first tried to just override it in System Preferences->Keyboard->Application Shortcuts, but that didn’t do anything. Next I found a post on macosxhints that offered a Terminal (defaults) command for changing default Application shortcuts. For example:

defaults write com.macromates.textmate NSUserKeyEquivalents -dict-add "Reformat and Justify" "nil"

Guess what? That didn’t do it. TextMate was still pwning the ^J shortcut. Next stop, the Resources folder of the TextMate application. There I found KeyBindings.dict, where it was easy to locate the offending shortcut. I commented out the line (//) and restarted TextMate. Ta. Dum. My new keyboard shortcuts now function perfectly.

By the way, the reason I didn’t use “k” for down is I actually do regularly use the kill keybinding to delete to the end of the line (as well as ^a to move to beginning and ^e to the end). Also, you might skip mapping “m” to down, as “n” right next to it is already mapped to moveDown:, as mentioned while complaining about Emacs keybindings. I have them both mapped now, so I can have lazy fingers if I want to. Further, note that these keybindings will not work when selecting text; once you press the shift key, you’re in a whole new world. You’d have map those as well if you wanted that functionality.

I’m happy now, and so are my fingers. Have any other brilliant keybinding stories? I’d love to hear them.

Related posts:

1. KeyBindings: new, improved “surround” commands
2. KeyBinding madness
3. The keys that bind: KeyBinding Madness part 2

Originally posted on BrettTerpstra.com at A quick TextMate KeyBindings tip

I’m using the PROMPT_COMMAND variable to run a few quick functions to generate the prompt. It doesn’t do anything processor-intensive, so I haven’t seen any lag caused by this one (unlike some of my previous experiments). PROMPT_COMMAND is set to call a function called, appropriately, prompt_command(). This, in turn, calls a few external functions defined in my .bash_profile. To use it, just stick all of the code below into your .bash_profile, and modify it as you see fit. Be sure to replace any definitions of PROMPT_COMMAND or PS1.

The prompt has a few unique features, and some “hidden” features:

• The current time is formatted just the way I like it. You can modify the fmt_time function with your own strftime strings as desired.
• The current 1m average CPU load is included in the prompt in dark grey, gathered using a quick uptime command.
• If the previous command returned an error message, the error code returned will show up at the end of the first line in red.
• If you use Git, and your current working directory is a Git repository, the current branch will be shown in green before the actual prompt on the second line. This might cause problems if you don’t have Git installed; if you see Git-related errors, you can remove the section of the code under the Git comment from if to fi. Also remove the ${BRANCH} from the last line of the prompt_command function.
• Lastly, it sets the title of the tab in Terminal to the last two portions of the current working directory (pwd) string, meaning the current directory and its parent directory.

All of the colors used in the prompt are defined as shell variables. In the final line of the prompt_command function, you can modify the colors just by replacing the color names in the line. That should be pretty self-explanatory.

prompt_command () {
    if [ $? -eq 0 ]; then # set an error string for the prompt, if applicable
        ERRPROMPT=" "
    else
        ERRPROMPT='->($?) '
    fi
    if [ "\$(type -t __git_ps1)" ]; then # if we're in a Git repo, show current branch
        BRANCH="\$(__git_ps1 '[ %s ] ')"
    fi
    local TIME=`fmt_time` # format time for prompt string
    local LOAD=`uptime|awk '{min=NF-2;print $min}'`
    local GREEN="\[\033[0;32m\]"
    local CYAN="\[\033[0;36m\]"
    local BCYAN="\[\033[1;36m\]"
    local BLUE="\[\033[0;34m\]"
    local GRAY="\[\033[0;37m\]"
    local DKGRAY="\[\033[1;30m\]"
    local WHITE="\[\033[1;37m\]"
    local RED="\[\033[0;31m\]"
    # return color to Terminal setting for text color
    local DEFAULT="\[\033[0;39m\]"
    # set the titlebar to the last 2 fields of pwd
    local TITLEBAR='\[\e]2;`pwdtail`\a'
    export PS1="\[${TITLEBAR}\]${CYAN}[ ${BCYAN}\u${GREEN}@${BCYAN}\
\h${DKGRAY}(${LOAD}) ${WHITE}${TIME} ${CYAN}]${RED}$ERRPROMPT${GRAY}\
\w\n${GREEN}${BRANCH}${DEFAULT}$ "
}
PROMPT_COMMAND=prompt_command
 
fmt_time () { #format time just the way I likes it
    if [ `date +%p` = "PM" ]; then
        meridiem="pm"
    else
        meridiem="am"
    fi
    date +"%l:%M:%S$meridiem"|sed 's/ //g'
}
pwdtail () { #returns the last 2 fields of the working directory
    pwd|awk -F/ '{nlast = NF -1;print $nlast"/"$NF}'
}
chkload () { #gets the current 1m avg CPU load
    local CURRLOAD=`uptime|awk '{print $8}'`
    if [ "$CURRLOAD" > "1" ]; then
        local OUTP="HIGH"
    elif [ "$CURRLOAD" < "1" ]; then
        local OUTP="NORMAL"
    else
        local OUTP="UNKNOWN"
    fi
    echo $CURRLOAD
}

Related posts:

1. Geeklet: Top CPU processes
2. oft: Bash function for opening a specific filetype
3. na: per-project todos in Terminal

Originally posted on BrettTerpstra.com at My new favorite Bash prompt