“Open URLs” is ideal if you collect browsing “sessions” in text files or notes in any format (possibly using tools such as TabLinks or EverSave). I often use TabLinks to save a collection of same-subject links to a note in nvALT and then drag and drop the text to re-open the whole session. It’s also very handy when someone emails you a list of urls that you want to open all at once (e.g. a design project with multiple versions and they couldn’t be bothered to make it a Dropbox gallery). If you’re on a page with a list of links and you want to open them all in tabs quickly, just view source, select the section with the links and drag the selection to the Destination in Dropzone. It will ignore duplicates and open one tab per unique link.

I expect this Destination will be available soon from the GitHub repo, but you can download it directly below if you’re using Dropzone and it happens to sound useful. Update: before I even got this post out, John Winter of Aptonic got this Destination on the Extend page of the Dropzone website. You can grab it there, too!

Related posts:

1. App Review: Dropzone
2. Mac App Giveaway: Dropzone
3. Is your URL too short? Try our system, free!

Originally posted on BrettTerpstra.com at “Open URLs” Dropzone Destination

I’ve created scripts for Notational Velocity/nvALT, MarsEdit, Scrivener and Evernote. The scripts will be part of the Marked Bonus pack, but are also available as a separate download here (see the end of the post). I would eventually like to incorporate the functionality directly into Marked, but it will take some time to add the necessary configuration options and make it an elegant fit.

The scripts work by using timestamps and polling with Ruby to detect changes within certain files and directories (varies from script to script)¹. The Evernote, nvALT and MarsEdit scripts can be run without arguments (or as LaunchAgents). The Scrivener script requires the path to the .scriv file for your project as the only argument.

The preview contents are always saved to ‘Marked Preview.md’ in your home folder. When you first start, you may need to create this file manually with a text editor and save it to your home folder. Once the scripts have run once, the file will exist and you can open it in Marked any time you’re working in a “watched” application.

All of this was inspired by this gist by myfreeweb. His method uses fsevents and Python, which is definitely more elegant in many cases. I switched it over to use Ruby and timestamps because I’m pretty lame with Python right now. If you want to take the basic ideas and convert them to use fsevents, please share! I’ll be happy to host and credit (or just link, if you prefer) any submissions.

I’m certainly taking requests for any other editors you’d like to have “watched,” so drop your vote in the comments.

Notes:

For all of these scripts, the easiest way to use them is to put them in a convenient folder (I use ~/scripts) and run chmod a+x path/to/script.rb to make them executable. With the exception of the Scrivener script (scrivwatch.rb), you can then just type the path and script name (e.g. ~/scripts/everwatch.rb) and hit Enter. They will run and watch for changes in their specific application until you cancel the command by typing Control-c.

The scripts will create a file in your home directory (modifiable in the script) called ‘Marked Preview.md’. Open that file in Marked; Marked will watch that file for changes that the scripts make.

You can create LaunchAgents for any of these (except, again, Scrivener) and run them automatically in the background if you know what you’re doing. If you don’t, you can still use an app like Lingon to do it.

Evernote (everwatch.rb)

To keep the ‘Marked Preview.md’ file synced with whatever note you’re currently editing in Evernote, start the script by running ~/path/to/everwatch.rb in Terminal. The script watches for changes to timestamps on any directory in Evernote’s data folder. This shouldn’t need to be adjusted. To update Marked, you’ll need to have “~/Marked Preview.md” open and then hit “Command-S” in your Evernote note. The autosave on Evernote will work, but it takes longer.

The HTML of the note is captured via AppleScript and run through textutil to remove the HTML formatting. This means that embedded images won’t come through, but those probably would have broken anyway. The script is specifically expecting you to write your notes in Markdown. If you’re not, I’m not sure why you’d want a Marked preview anyway…

Even with “Command-S” there’s still a 4–5 second delay on the update, as it takes a bit for Evernote to write out to the file, the script to poll through and notice the change, the content to be pulled via AppleScript and written to the preview file and then for Marked to pick up on the change there. Considering all of that, 4–5 seconds isn’t too bad. If someone can think of a faster way, I’m certainly open to it.

Scrivener (scrivwatch.rb)

The Scrivener script watches the RTF files that Scrivener keeps within the project as you write. If you set Scrivener’s preferences to auto-save 1 second after you stop typing, Marked will stay pretty snappy on the updates without any further intervention.

To launch (assuming you made the script executable as detailed at the beginning of this section), open Terminal and type path/to/scrivwatch.rb /path/to/YourDocument.scriv. Example: ~/scripts/scrivwatch ~/Documents/Thesis.scriv. The script will take it from there and run until you interrupt with Control-c.

The files Scrivener stores are Rich Text Format, so Marked can’t view their contents directly. The script runs the most recently-edited file through textutil to convert from RTF to text. That gets passed to the ‘Marked Preview.md’ file for Marked to display. Only the portion of your Scrivener document that you’re currently editing will be displayed. I played with concatenating the whole document for preview, but it’s not easy to determine the order to display all of the individual files in. Again, if anyone has further ideas, please share!

MarsEdit (marswatch.rb)

Thanks to Daniel Jalkut for an assist with this one. It watches the MarsEdit autosave folder for any changes, and then uses AppleScript to get the full contents of the editor (post and continued) when one is detected. Because the autosave can be a bit slow on the draw, it continues updating every second for 10 seconds, whether there’s a change or not. If no more changes are detected within 10 seconds, it chills out in the background until the next one is detected.

Run marswatch.rb to start polling for changes, open ‘Marked Preview.md‘ from your home folder and Marked should start updating the preview automatically as you make changes in a MarsEdit post.

Notational Velocity/nvALT (nvwatch.rb)

If you’re using Notational Velocity (or my fork, nvALT), you can tell it to save your notes as text files on your drive. This script will watch these text files for updates, then display the contents of the most recently-edited note. It’s a workable solution, at least until I get better integration worked into nvALT directly.

You need to configure the script to point to your chosen folder for note storage, and if you’re using any unique extension, you’ll need to add to or modify the list in the script. It should be pretty obvious what needs to be set if you look at the top of the script.

Download

I’m sure I forgot some details in this writeup, so if you have any questions, leave a comment and I’ll add information as needed.

The most recent versions of the watcher scripts are now included the the Marked Bonus Pack.

You can find out more about Marked at the Marked website.

Related posts:

1. Preview a full Scrivener document in Marked, live
2. ScrivWatcher droplet, an easier live Scrivener preview
3. The second Marked giveaway!

Originally posted on BrettTerpstra.com at Marked scripts: nvALT, Evernote, MarsEdit, Scrivener

I’d like to welcome Donald Curtis as a guest blogger today, here to talk about a very cool script we worked on to add some Markdown love to MindMeister. It started with a DM from Donald on Twitter with a link to a GitHub gist, and after some back and forth it became a very cool (and useful) tool. Cool enough that I really wanted to share it here. Since the script is his brainchild and almost entirely his handiwork, I thought it would be cool if Donald did the honors.

The backstory

I am nearing the end of my first semester as a professor at a small liberal arts college. My graduate school years left me fairly detached from some of the topics I learned in my undergrad years and so I spend a decent amount of time simply re-aquainting myself with material. It is easy to digest the second time around, but as I process the material I also have to think about how and what to present.

Mind maps have turned out to be an exceptionally useful tool for organizing the key ideas I want to cover. And for whatever style of teaching I employ, they end up being a great in-class reference.

When I first started toying with the idea of incorporating mind maps, I did the search for the right software tool. I considered software-only solutions such as iThoughts HD for iOS and My Thoughts for Mac, with Dropbox as the glue. Both of these apps look amazing and sometimes that’s all the motivation you need.

After reading Brett’s Appstravaganza I gave MindMeister a spin (because they offer a free as in beer account). By the time I started paying for the account, I was in. You can read more about the app in Brett’s discussion about mind mapping, but in summary: free trial, web-based (read: multi-platform), decent iOS app, looks good, and roughly equivalent yearly cost to software-only solutions. The added bonus for my application is–on the occasion I have an external link to a picture or movie–MindMeister works on the lecture machines.

Stepping back, I assume teaching isn’t a scenario that a lot of the readership can associate with. Not to worry, mind maps are useful in a wide variety of scenarios.

The MindMeister Markdown Showdown

MindMeister lacks one feature to satisfy the Markdown users among us: export to Markdown. Brett recently had a Quick Tip that showed how to use Mindjet MindManager to get a MindMeister map to HTML through Markdown. I don’t use Mindjet and I didn’t want to really have to install another piece of software and figure out how to migrate my maps through it. After all, the approach was described as a “quick hack” so I assume if I went ahead and described it as a bit contrived–in order to make myself sound smarter–there would be no hard feelings [Ed: there would not]. I would never say such a thing though. It gets the job done.

In order to have a more elegant solution and teach myself Ruby, I wrote up a small script that uses the MindMeister API to pull down maps as a markdown-formatted outline. I named the script for clarity as mindmeister2md.rb. With help from Brett to refine much of the output–clean up newlines, fix escaped characters, add notes, add pictures–the core script that I wrote is now very usable.

Overview

The script has two functions,

• list all your maps
• output a map as markdown

When run with no arguments, the script prints a menu of maps available for you to select:

   Available MindMeister Maps
   ---
    1: Software                      ( 2011-10-31 04:13:58 ) [ 117882387 ]
    2: Internet Layer Protocols      ( 2011-10-27 18:10:26 ) [ 120233062 ]
    3: Network Layer                 ( 2011-10-27 16:41:09 ) [ 119115816 ]
    4: HTML                          ( 2011-10-24 17:59:28 ) [ 117882606 ]
    5: Newbie                        ( 2011-10-24 03:53:40 ) [ 119564927 ]
    6: Ethernet                      ( 2011-10-24 03:53:00 ) [ 116616227 ]
    7: My First iPad Map             ( 2011-10-21 14:19:07 ) [ 119100256 ]
    8: My First iPhone Map           ( 2011-10-21 14:17:30 ) [ 119262965 ]
    9: Threads                       ( 2011-10-20 15:14:29 ) [ 116945908 ]
   10: Computer Hardware             ( 2011-10-12 19:24:19 ) [ 117875898 ]
   11: ACM Programming Tips          ( 2011-10-11 04:03:21 ) [ 117550509 ]
   12: Interprocess Communication    ( 2011-10-04 02:54:56 ) [ 116511362 ]
   Selection: 

Optionally you can pass either the name of a map (case insensitive) or the map id (given in square brackets in the menu) as argument(s)¹. Both of these would return the “My First iPad Map”,

   ./mindmeister2md.rb my first ipad map
   ./mindmeister2md.rb 119100256

By default the script outputs the markdown to the screen. There is an optional command-line argument (-o) which will write the markdown to a file.

For the UNIX geeks: Only the generate markdown is sent to standard output (STDOUT). For Mac users this means the ability to copy the markdown to the copy buffer:

    ./mindmeister2md.rb my first ipad map | pbcopy

Configuration

There is one downside to using the MindMeister API with a script: each user needs to have a MindMeister api key and secret in order to use the script². Rather than edit the source code, the script relies on a configuration file named .mindmeister2md in the home directory. The file will be created automatically the first time you run the script; it will complain to you about you needing to update the configuration and specify an API key and your music being too loud.

The configuration file looks like this:

  --- 
   indent: 4
   list_level: 2
   api_key: 
   secret: 

You get both api_key and secret from the MindMeister api request page. The other two options you can set are:

list_level

The level in the map where lists should begin. At a list_level of 2, the first two levels of the map tree structure are represented as markdown headings, rather than as lists. A list_level of 0 will mean that the map will be exported as a single giant list.

indent

specifies the number of spaces that represent a single indent in the list.

Command Line Options

Most of the configuration file can also be changed at run-time using optional command line arguments. There is also an option to simply print the maps without actually printing any of them out as well as output to a file.

Usage: mindmeister2md.rb [options]

-l, --list

List available maps and exit.

-i, --indent <indent>

Set number of spaces for each indent level. Like temporarily setting indent in the configuration file.

-s, --listlevel <list_level>

Set the level at which lists should start. Like temporarily setting list_level in the configuration file.

-o, --output FILE

Write output to FILE.

-h, --help

Print command-line argument help.

Thanks to Brett for his major contributions to the script–which actually made it useful–and for letting me send him this writeup. You can find me on Twitter, Github, and I sometimes post bad prose on milkbox.net.

Check out mindmeister2md on GitHub, or download below.

Download

Related posts:

1. Quick Tip: MindManager to (clean) HTML
2. When plain text is wrong
3. The Mac and iOS mind mapping app extravaganza

Originally posted on BrettTerpstra.com at The MindMeister Markdown Showdown

It’s designed to work with promo code giveaways. So far, that’s what my giveaways have been. If I end up running a giveaway with a different registration method, I’ll extend the script and post an update for anyone interested.

This method currently has two requirements/limitations based on my own needs and setup. First, it only works with Mail.app for collecting entries and sending notifications. Second, the regular expressions it uses to find the entrants name, email and IP address are based on the standard WordPress comment notification emails. The basic idea here could easily be applied to other AppleScript-able email applications and modified to parse any format, but I’ll leave that up to intrepid readers for now.

How it works

First, I do a search for the subject line in Mail. All of the comment notifications that WordPress sends me for the post have the same subject line, so that gathers them all very quickly. All that matters is that I can select them all before running the script.

Next, I run the AppleScript. It begins by asking me for the giveaway app’s name and requests my list of promo codes. Then the script pulls the names and the message content from each selected email, passing the information to a Ruby script which scans the content for the actual email address (necessary because the actual sender on the email is always my WordPress address) and entrant’s name/handle and IP. The list of results are then passed to a second Ruby script along with the promo codes. This script checks for duplicates in the emails and IPs, picks enough random numbers (range 0 — number of entrants) to match each code provided (recursive function to avoid duplicate numbers). The Ruby script then opens a new message in Mail.app for each winner, and populates it with recipient, subject, congratulatory message (including code) and signature. It also adds the mailto: link with all of this info to an HTML file on the Desktop for reference.

It needs some improvements, especially in the mail creation routine. It currently uses the mailto AppleScript command, but really should create the outgoing message step by step, which would ultimately allow for complete automation at some point. For the time being I still want to be able to confirm the winners and message content anyway; I’ll automate more when I have full trust in it.

The AppleScript

(* 
PickWinners by Brett Terpstra, 2011, freely distributed
Picks random winners from selected WordPress comment notification emails in Mail.app
Checks for duplicate emails and IP addresses
On run, requests Application title and a newline-separated list of promo codes
Picks winners from list for each promo code and opens ready-to-send notification emails in Mail.app
Saves list of winners in HTML file with mailto links (including message and promo code)
*)
 
set pickWinnerScript to (path to me) & "Contents:Resources:Scripts:pickwinners.rb" as string
set extractEmailScript to (path to me) & "Contents:Resources:Scripts:extractemail.rb" as string
property winners : ""
set _res to display dialog "Application name?" default answer ""
set appname to text returned of _res
set _res to display dialog "Enter promo codes" default answer "Paste codes, one per line"
set codes to text returned of _res
 
tell application "Mail"
	set _sel to the selection
	set entries to {}
 
	repeat with _msg in _sel
		set nameAndEmail to do shell script "\"" & (POSIX path of extractEmailScript) & "\" \"" & content of _msg & "\""
		set end of entries to nameAndEmail
	end repeat
 
	set {astid, AppleScript's text item delimiters} to {AppleScript's text item delimiters, "
"}
	set emails to entries as string
	set AppleScript's text item delimiters to astid
 
	set winners to do shell script "\"" & (POSIX path of pickWinnerScript) & "\"  \"" & appname & "\" \"" & codes & "\" \"" & emails & "\""
end tell
 
if winners is "error" then
	display dialog "There was an error generating winners"
else
	set _btn to display dialog "Winners written to " & winners buttons {"OK", "Open in Safari"}
	if button returned of _btn is "Open in Safari" then
		tell application "Safari" to open (POSIX file winners) as alias
	end if
end if

extractemail.rb

#!/usr/bin/env ruby
 
input = ARGV.join(" ")
emailmatch = input.match(/E-mail : (.*)/)
namematch = input.match(/Author : (.*?) \(IP: (.*?)\)/)
 
print "#{namematch[1].strip} <#{emailmatch[1].strip}> (#{namematch[2].strip})"

pickwinners.rb

#!/usr/bin/env ruby
require 'ftools'
 
appname = ARGV[0]
ARGV.shift
codes = ARGV[0].split
count = codes.length
ARGV.shift
input = ARGV[0].split("\n").uniq
 
norepeat_email = []
norepeat_IP = []
entries = []
 
input.each {|entry|
  name,email,ip = entry.scan(/^(.*?) *<([^ ]+)> \((.*?)\)/)[0]
  unless (norepeat_email.include?(email) || norepeat_IP.include?(ip))
    norepeat_email.push(email)
    norepeat_IP.push(ip)
    entries << { 'name' => name, 'email' => email }
  end
}
 
def pick_number(max,numbers)
  num = rand(max)
  if numbers.include? num
    pick_number(max,numbers)
  else
    return num
  end
end
 
randoms = []
count.times do
  randoms.push(pick_number(entries.length,randoms))
end
 
winners = []
randoms.each_with_index {|winner,i|
  entry = entries[winner]
  name = entry['name']
  email = entry['email']
  mailto = %Q{mailto:#{email}?subject=Congratulations #{name}, you won!&body=Here is your promo code for #{appname}: #{codes[i]}%0A%0AThanks for reading!%0A%0A-Brett}
  link = %Q{<li><a href="#{mailto}">#{name} <#{email}></a></li>}
  winners.push(link)
  %x{echo 'tell application "Mail" to mailto "#{mailto.gsub(/'/,"\'")}"'|osascript}
}
 
if winners.length == count
  output = "<ul>"
  output += winners.join("\n")
  output += "</ul>"
 
  outfile = File.new(File.expand_path("~/Desktop/#{appname}Winners.html"),'w+')
  outfile.puts output
  outfile.close
  puts File.expand_path("~/Desktop/#{appname}Winners.html")
else
  puts "error"
end

It’s not the most elegant solution, but it does the job of ensuring randomness and handling the nitty gritty parts of running a contest.

Related posts:

1. Listary giveaway, get yours!
2. Five Yoink promo codes up for grabs!
3. iOS App Giveaway: WriteUp

Originally posted on BrettTerpstra.com at Automating random giveaways, v1.0

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

A reader named Tony left a comment on my Duplicating Safari browsing sessions post, recommending that I try out appscript for my AppleScript bridging needs. I frequently use system calls to osascript to do this, and I’ve shied away from scripting bridges in the past because they make things much harder to share and distribute. I thought I’d give it a try, though.

I like it. I like it a lot. It’s frustrating that I can’t just hand you this script without a list of requirements and dependencies, but I’m going share it anyway, just to show off some of the appscript’s capabilities.

What I built was a CLI for OmniFocus. I had an AppleScript/Ruby monstrosity that actually worked with TaskPaper, The Hit List, Things and OmniFocus, but that one got out of hand. I took the good parts of it, concentrated on OmniFocus and converted it to appscript in short time. The result is OTask.

Requirements

You need a few things before this will even think about running for you. RubyGems is a must. I still haven’t figured out if that’s part of the default OS X install or not, but if you have Developer tools, you’ve got it. Then you need the ‘rb-appscript’ gem. You also need the gems ‘chronic’ and ‘amatch’. You can install each by using gem install gemname, and you may have to run the command with sudo, depending on your system’s permissions. If you’re still on board, here are the docs, and the script is on GitHub.

Documentation

OTask uses a custom syntax to allow entry of the various elements of an action in one line of text. The following formats can be used anywhere in the line, with the exception of the flag (!) which must be the last character on the line, preceded by a space.

• @context (fragment, no spaces)
• #project (fragment, no spaces)
• due(due date) (can be shortened as d(date))
• start(start date) (can be shortened as s(date))
• (notes)
• ! (sets task as flagged)

Contexts and project specifiers should not include spaces. The algorithm that is used will find the best match for the string you give it, so you only need to include enough of it to distinguish it from other contexts or projects. For example, if I were going to put an action directly into my Markdown QuickTags folder, I could just use “#mdqt” and it will find it. “@corr” will get me the “correspondence” context.

Dates are entered in natural language format. You can type “tomorrow,” “in 3 days,” “next tuesday,” etc. You can also use “+3″ to set a date 3 days from the current day, “+7″ for a week, and so on.

Command line options

–h, –help Displays help message
–q, –quiet Output as little as possible, overrides verbose
–V, –verbose Verbose output
–g, –growl Use Growl for feedback

Example usage

$ otask "Write a letter to mom"

This will put a task into your inbox with the name “Write a letter to mom.” Nothing else will be set, it will wait there for you to pick it up.

$ otask -g "Pick up the kids from school @err #single due(today 3pm) !"

This creates a new task in a project called Single Tasks, with a context of “errands”, a due date of 3pm on the current day, and flags the task.

The task will go to your inbox by default, and–if provided–project and context will be set. Your settings for automatic cleanup will determine what happens after that. Task elements not specified are left unset.

The -g parameter gives us our feedback via Growl, which is handy if you’re calling it from a background script or application launcher like Quicksilver or LaunchBar.

$ otask "Brainstorm for the morning meeting (Bill had some ideas, it might be worth checking in with him this afternoon) d(tomorrow 8am) #hipstartup @think"

This will create a task with a note. Everything in parenthesis is removed from the task name and placed into the notes of the action, sans parenthesis. Note that the due date prefix can be shortened to just “d,” (and the start date prefix can be just “s”).

OTask looks for notes in parenthesis, but it can also receive piped input from other applications as a note for the task. If you wanted to include text from a file, the output of a command or the plain-text contents of your clipboard, you can just pipe the output into the command, specifying the rest of the options as usual.

$ pbpaste | otask "Notes from the morning meeting @ref"

That would take the current contents of your clipboard and make them the attached note on the “Notes from the morning meeting” task (with the context “reference”).

Calling from LaunchBar (et al.)

You can do this with any app that can run a script with input, or call it from automated scripts if you could think of a reason to. Below is the AppleScript for a LaunchBar action. Create a new script in AppleScript Editor and paste the code in. Edit the path in the last function to point to wherever you put the otask script. Save the AppleScript as OTask.scpt in ~/Library/Application Support/LaunchBar/Actions.

You’ll find the Action in LaunchBar after it indexes. Type ‘ota’ (or as much as you need to get it to come up) and then press space bar. Use the syntax shown above to write out your action and its elements, but leave out the ‘otask’ part and any parameters. Hit return and Growl (you have it installed, right?) will tell you what’s up.

on handle_string(actionString)
	if (length of actionString is not 0) then
		my runRubyScript(actionString)
	end if
	open location "x-launchbar:hide"
end handle_string
 
on runRubyScript(action)
	set res to do shell script "$HOME/scripts/otask.rb -g \"" & action & "\""
end runRubyScript

Download

https://github.com/ttscoff/OTask

Related posts:

1. Moving day
2. Things tasks from the command line
3. Totally TaskPaper

Originally posted on BrettTerpstra.com at OTask: CLI for OmniFocus

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

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

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

The basic goals:

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

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

Here’s the command line version:

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

Installing

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

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

Customizing

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

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

Using other browsers

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

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

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

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

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

Executing arbitrary code

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

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

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

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

Download

Related posts:

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

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

In the process, I wrote a quick TextMate command which lets me enter a date in natural language and have it converted to whatever format I need for my system. It has variables at the top of the command for defining the date format and output string template. I packaged it up in its own little bundle for people to play with. The command is similar to what I built as a TaskPaper script a while back. Just download at the end of the post, unzip and double-click to install.

Customizing

The output format of the command defaults to a full date in the system’s preferred format. This makes it easy to see the effect of various strings. For most purposes, you’ll want something more along the lines of “2011–02-22″ instead. To change the format, you just need to edit the dateformat variable at the top of the command’s script.

To edit the command, just go to Bundles > Bundle Editor > Show Bundle Editor and find the Date Entry bundle. Select the Natural Date Entry command and edit it in the field on the right.

Date Format

There’s a commented-out dateformat replacement above the current variable, and you can modify it to fit whatever you need. Don’t forget to comment out or remove the current variable if you uncomment the one above it. The % format elements use Ruby’s strftime format. I built the command to work with GTDAlt and TaskPaper, and on my system both use the YYYY-MM-DD format, so that’s what the secondary option is set to.

Output Template

To be practical, you probably also need to output some delimiters with the date. In GTDAlt, it would look like “due:[2011–02-22]”, and in TaskPaper it would look like “@due(2010–02-22)”. You can set this up using the outputtemplate variable below dateformat. It uses %date% as a placeholder which will be replaced with the date in the format you specified above. As an example, if you wanted to use the command with TaskPaper files, you would set it to '@due(%date%)'.

Usage

The command uses Command-Shift-D by default, but you can change that to whatever’s clever when you’re in the Bundle Editor. When run, it pops up an input dialog courtesy of TextMate’s built-in dialog system. You can enter text in an intuitive natural language format and it will output the date based on the variables you’ve defined. Here are some example strings:

• tomorrow
• tomorrow 3pm
• wednesday
• wednesday morning
• wed
• next thursday
• in one week
• in three days
• in 3 days

You get the idea. I also set it up to take “+” modifiers. You can add any number of days at the end of a string, or just use the plus modifier to add days to today. For example:

• thu+7
• +2
• tomorrow + 3

It will roll with any of those punches. Abbreviated days have to be three characters, i.e. mon, tue, wed, thu, fri, sat, or sun.

Moving the command

This command has to be distributed in a bundle because it requires the Ruby library “Chronic” for the date conversion. The library is included in the Support/lib folder of the bundle. If you happen to have RubyGems installed, you can install the Chronic gem (sudo gem install chronic) and then modify the command to allow you to put it wherever you like without needing the support folder at all. To make the command use the gem instead of the bundled library, change the require statements in the command to look like this:

SUPPORT = ENV['TM_SUPPORT_PATH']
BSUPPORT = ENV['TM_BUNDLE_SUPPORT']
DIALOG = ENV['DIALOG']
require SUPPORT + '/lib/ui'
require SUPPORT + '/lib/exit_codes'
require 'rubygems'
require 'chronic'

It would also be pretty easy to port to any other system, including an OS X system service. You’d just need to make sure you include the Chronic library, either bundled or install the gem, and find a way to get the text input without using TextMate’s dialog. CocoaDialog or a service that acts on selected text would fit the bill.

I think this will be handy for more than just to-do lists. Let me know if you find a use for it elsewhere!

Man, it took me twice as long to write that post as it did to put together the command and the bundle. Like I said: Sunday.

Download

Related posts:

1. OS X Service for natural language dates
2. Natural language dates for TextExpander
3. A couple of TextMate Macros for Markdown lists

Originally posted on BrettTerpstra.com at Natural language date conversion for TextMate

I used a Gem called Raingrams, along with Maruku for processing Markdown to HTML. See, if I had it output Markdown to begin with, I had the flexibility to do both easily. I’m posting the main script, which you can modify to output various elements and amounts of text. Even if you don’t know ruby, you can probably find your way around with a little guessing. In the section after the function definitions you can take any of the lines and output what you want by mixing or removing those elements.

This script requires Rubygems, and the Raingrams and Maruku gems. If you have Rubygems installed, you can just type sudo gem install raingrams and sudo gem install maruku at the command line to quickly get both on your system. If you don’t have Rubygems, you might want to skip this one, as you’re in for more trouble than this will pay off…

You’ll also need a text file to pull from. I’m using a chopped up version of 1984, with just enough paragraphs to get some good randomness. You can find it here, if you want it. Otherwise, choose your favorite text file and make it long enough to be random and short enough to be fast. That might take some experimentation. Put the text in a file called inputtext.txt in a directory called words in the root of your home folder. The final path should look like /Users/[YOUR USER NAME]/words/inputtext.txt.

The big script

The script should have enough comments to make it relatively easy to dissect and rebuild as a TextExpander snippet for any individual part of it.

#!/usr/bin/env ruby -rjcode -Ku
 
require 'rubygems'
require 'raingrams'
require 'maruku'
 
include Raingrams
 
# All (min,max) pairs need max > min
 
@model = BigramModel.build do |model|
  model.train_with_text File.new(File.expand_path('~/words/inputtext.txt'),'r').read
end
 
@model.refresh
 
# generates a paragraph with random sentences
# min = minimum sentences
# max = maximum sentences
def graf(min,max) 
  # grab the paragraph and split it into words
  para = @model.random_paragraph({:min_sentences => min,:max_sentences => max }).split(' ')
  # add a random italics element
  em = (rand(para.count - 10) + 10)
  para[em] = "*#{para[em]}*"
  # add a random bold element
  strong = (rand(para.count - 10) + 10)
  # make sure they don't overlap
  strong = strong - 2 if strong == em
  para[strong] = "**#{para[strong]}**"
  # add a multi-word link
  link = (rand(para.count - 10) + 10)
  linkend = link + (rand(6) + 2)
  para[link] = "[#{para[link]}"
  para[linkend] = "#{para[linkend]}](http://dummy.com)"
  return para.join(' ')
end
 
# returns a random sentence, used in headlines
# min = minumum words, max = max words
def sentence(min,max) 
  return @model.random_sentence.split(' ')[0..(rand(max - min)+min)].join(' ')
end
 
# returns a random list
# type = ul or ol
# min = minimum number of list items
# max = maximum number of list items
def list(type,min,max)
  list = '';
  prefix = type == "ol" ? " 1. " : " * "
  (rand(max - min) + min).times do
    list += prefix + @model.random_gram.to_s + "\n"
  end
  list += "\n\n"
  return list
end
 
# Sequentially builds an output variable (o)
# Chop this apart to make snippets as needed
 
# Level 1 headline
o = "# " + sentence(2,5) + "\n\n"
# 2 medium paragraphs
2.times do
  o += "#{graf(4,6)}\n\n"
end
# Level 2 headline
o += "## " + sentence(4,7) + "\n\n"
# 1 short paragraph
o += graf(2,4) + "\n\n"
# an unordered list
o += list('ul',5,8) + "\n\n"
# 1 more long paragraph
o += graf(6,8) + "\n\n"
# Level 3 header
o += "### " + sentence(5,9) + "\n\n"
# medium paragraph
o += graf(4,6) + "\n\n"
# ordered list
o += list('ol',5,8) + "\n\n"
 
# Process Markdown to HTML
 
# if you want just the Markdown
# delete the two lines below
# and replace with 'puts o'
doc = Maruku.new(o)
puts doc.to_html.gsub(/\/li>\n/,'/li>').gsub(/\/li><\/([uo])l/,"/li>\n</\\1l")
# the gsub is just to clean up maruku's double-spaced list output

Here’s some sample output, generated in nvALT, using TextExpander with this script as a shell Snippet, and posted to Peggd. As you can see, it needs some fine tuning. The list items, strong and em could be multi-word, the links could check to see if there was a period-space-capital and prevent overlapping sentences, etc. It’s enough for my purposes, though, and between the script and this post, I’ve lost over an hour of what was supposed to be a productive weekend. I’m out!

Related posts:

1. The QuickCal winners
2. Random Lipsum for TextExpander
3. Grabbing a Mac app’s icon: advanced Bash usage

Originally posted on BrettTerpstra.com at Dammit. Again with the Lipsum.

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

#!/usr/bin/env ruby -wKU
 
require 'open-uri'
require 'cgi'
 
USER_NAME = 'username' # Your login name
API_KEY = 'yourlongapikey' # http://bit.ly/a/your_api_key
 
def entity_escape(text)
  text.gsub(/&(?!([a-zA-Z0-9]+|#[0-9]+|#x[0-9a-fA-F]+);)/, '&')
end
 
def make_link(text)
  case text
  when %r{\Ahttps?://.*?\.\w{2,4}.*?\z}:
    entity_escape(text)
  when %r{\A(www\..*|.*\.\w{2,4})\z}:
    "http://#{entity_escape text}"
  when %r{\A.*?\.\w{2,4}\/?.*\z}:
    "http://#{entity_escape text}"
  else
    nil
  end
end
 
url = make_link %x{__CF_USER_TEXT_ENCODING=$UID:0x8000100:0x8000100 pbpaste}.strip
res = open("http://api.bit.ly/v3/shorten?login=#{USER_NAME}&apiKey=#{API_KEY}&longUrl=#{CGI.escape(url)}&format=txt").read unless url.nil?
 
begin
  print res unless res.nil?
rescue
  exit
end

The API can output JSON and XML, which would be more appropriate on most occasions, but the “txt” format (which only includes the shortened link) is perfect for this situation. Enjoy!

Related posts:

1. TextExpander experiments
2. SMS from the command line with Google Voice
3. A System Service for to. url shortening

Originally posted on BrettTerpstra.com at TextExpander: bit.ly with authentication

To install, just download the file below, unzip it (double click), and move it into [your username]/Library/Services. To use it, select text in any Cocoa app (Safari, Mail, and most Mac apps) and look under the application menu in the menubar for the Services submenu. Trigger it from there, or just right click on your selected text and you should get the same services menu as a contextual menu item. If you’re feeling clever, go into the Keyboard preferences pane, choose Keyboard Shortcuts -> Services and double click the blank space to the right of the service to assign a hotkey. As long as that hotkey isn’t already assigned by the application your using, you can trigger the service with it any time you have text selected.

Related posts:

1. Songza Lucky Link Service
2. Songza is back!
3. Auto-link text service updated

Originally posted on BrettTerpstra.com at Updated: Songza Lucky Link Service

Another post, quickly and with less explanation…

The fact that Evernote processes HTML so much better than it does plain or rich text got me thinking and tinkering. I use Markdown (actually, MultiMarkdown) constantly, and it does a great job of turning plain text into valid markup. With (Multi)Markdown, even plain text becomes HTML that–when imported into Evernote–retains most of its formatting. To answer your question, no, I’m not obsessed with Evernote, I’m obsessed with problems I think I could solve. It’s unhealthy.

Please note, this requires that you have Fletcher Penney’s MultiMarkdown installed in ~/Library/Application Support/MultiMarkdown, and that the Perl files (MultiMarkdown.pl and SmartyPants.pl) are located in a ‘bin’ subdirectory (which is the default install). If you don’t have MultiMarkdown, you should get it anyway (all the cool kids have it), so head over to the download page and grab a copy. Now, on with the show.

I set this up originally as a TextMate command, intending just to be able to clip code snippets and free-form text to Evernote without thinking too much about it. That worked well, so I modified it to work as a System Service. Specifically, a Snow Leopard service, but I’m providing the Ruby script here and it can be modified for any Mac setup you want.

While it will work just fine on plain text with no markup, it does have a couple of “special” features. If you start a line with a # and a space (e.g.: # This is my header), which is a Markdown convention for a first-level heading, it will use that as the title for the note and strip it out of the text in processing. It only uses the first one it finds, but it will strip out any first-level headers in the selection. I’ll probably modify that later, or just have it leave them in. Also, a line that begins with “tags:” followed by a space and a comma-separated list of words will be split up and used to tag the new note. This is also stripped before processing. It handles spaces in multi-word tags, and odd marks at the beginning or end of a tag, but only one punctuation character, and only at the beginning or end of a tag. The code follows…

Here’s the Ruby code, messy as it may be:

    #!/usr/bin/env ruby -rjcode -Ku
    # requires that MultiMarkdown be installed in ~/Library/Application Support/MultiMarkdown
    # That, or edit the script to point to yours :)

    ARGF.each do |f|
    input = f
    contents = ''
    tags = ''
    title = nil

    def e_as(str)
        str.to_s.gsub(/(?=["\\])/, '\\')
    end
    input.each_line { |line| 
      if line =~ /^# (.*?)/
        title = line[2..-1]
        break
      end
    }
    title = %x{date '+Clipped note: %A, %B %d, %Y at %l:%M %p'|tr -s " "} if title.nil?

    input.each_line { |line| 
      if line =~ /^[Tt]ags: /
        tags = line[5..-1].split(',').map {|tag| tag = tag.strip.gsub(/^(.)?\b|\b(.)?$/,"\\2\"\\1") }
        break
      end
    }

    IO.popen('"$HOME/Library/Application Support/MultiMarkdown/bin/MultiMarkdown.pl"|"$HOME/Library/Application Support/MultiMarkdown/bin/SmartyPants.pl"', "r+") do |io|
     input.each_line { |line| 
        io << line unless line =~ /^# |[Tt]ags\: /
     }; io.close_write
     io.each_line do |line|
       contents << line
     end
    end
    tags = " tags {#{tags.join(",")}}" unless tags.empty?
    %x{osascript -e 'tell application "Evernote" to create note with html "#{e_as contents}" title "#{title}" notebook "Unfiled"#{tags}'}
    end

You can create a System Service in Automator with it, set up a command in TextMate, or do whatever else you can think of. If you just want to download the service and try it out, I’ve made it available here. Unzip and copy it to ~/Library/Services (in your home folder). If you set it up as a System Service, assign a shortcut key in the Keyboard pane of System Preferences.

It does choke once in a while, apparently on Markdown-generated code snippets, but I haven’t quite narrowed down why, yet. I’ll update the code if I figure that one out. Overall, though, it makes pretty clippings and allows you to use some Markdown syntax to spice up your text without having to touch the (regrettably abominable) Evernote editor.

Related posts:

1. Taking the Markdown to Evernote service further
2. Evernote Site Memory tagger for WordPress
3. A Service for writing MultiMarkdown footnotes inline

Originally posted on BrettTerpstra.com at A better System Service for Evernote clipping — with MultiMarkdown

This is a stripped down version of a command I have in the TextMate bundle we use at TUAW. It allows you to select any basic numeric equation and evaluate it, replacing the selected text with the results. It will ignore your text if it contains anything but numbers and basic mathematical symbols. Sure, there are plenty of ways to do calculations in OS X (Spotlight, Launchbar, Quicksilver), but I’ve had more and more incidents lately where I just wanted to do quick calculations inline, so I whipped this up. A little explanation…

The service is built for Snow Leopard only, but I’m including the code here because it could be wrapped up in ThisService or Bellhop pretty quickly for Leopard. It’s built in Ruby and uses the eval function to process text such as 20*(3.5/2) and return the result. It will add commas to numbers longer than 3 digits, but I stripped out the part of the original command that trimmed decimal places; I figured the accuracy might be important and the results are easy to edit manually in this case. I also added a silly feature that I actually find quite useful: it evaluates +/- percentage strings, such as 23.99-15%, which I find most useful for calculating savings during sales or quickly handling markup or tax on services and goods. It can’t get too complex, but for most everyday purposes, it does a good job.

The code:

def ts( st )
  # Adds commas to longer numbers
  # Removes .00 left over from % calculations
  mynum = st.to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse
  dec = mynum.split('.')
  return dec[0] if dec[1].to_i == 0
  mynum
end

ARGF.each do |f|
    # check if the text passed is actually an equation
    if f.match(/^[\%\$\d\*\/\+\-,\. \(\)]+$/)
        # add a preceding 0 to decimals passed for floating point calculation
        num = f.gsub(/(^|[^\d])(\.\d+)/,'\10\2')
        # convert basic percentage equations for eval
        num = num.gsub(/([\d\.]+)(?:\s+?)?([+-])(?:\s+?)?([\d\.]+)%([^\d]|$)/,'\1\2(\1*(\3.to_f * 0.01))\4')
        # process the result to add commas, trim unnecessary decimal places
        print ts(eval(num).to_s)
    # if it's not an equation, return the input (no effect)
    else
        print f
    end
end

You can download a ready-to-go Snow Leopard service, or build your own with the code above. Don’t forget to use the Keyboard preference panel to assign a keyboard shortcut to it (I’m using Control-Shift-=). I’d love to hear back if you find it useful!

Related posts:

1. Clippable to Evernote Snow Leopard Service
2. Updated: Songza Lucky Link Service
3. SMS from the command line with Google Voice

Originally posted on BrettTerpstra.com at A (fairly) simple equation evaluation service for Snow Leopard