I get a lot of one-off requests for scripts and tips on how to handle tasks specific to people’s workflow or writing style. I generally keep myself pretty busy, so I usually reply with a quick idea or thought and leave it up to them to run with it. David Coleman emailed me this morning, though, with a request that struck me as an interesting enough idea to whip up a script before work.

What David wanted to do was take the idea behind my “Inline Links to References” command in the Markdown Service Tools and do something similar for footnotes, allowing him to write footnotes inline in a paragraph and have them converted before processing with MultiMarkdown. It’s not such a chore to skip a few lines and drop in the footnote syntax that this should be part of the spec, but it is something I would find handy in several situations. So…

The format I picked uses a syntax like this to denote a footnote:

This is the regular text(*This is the footnote*), and you can drop the footnote in at any point.

The Service can handle footnotes inside of lines, at the end of lines, spanning multiple lines with breaks (creates paragraphs) and does fine with Markdown within the footnote. One nice thing about this syntax is that–if you’re previewing as you write–it italicizes the output to differentiate it until you’ve used the service to move it out of the main text.

Multi-line footnotes need to begin at the end of a line of text, and just use double-newlines to separate paragraphs within the footnote, e.g.:

...the end of the paragraph. (*This is a footnote

which is going to span

more than one line*)

Here’s the script, also available as a Service download at the end of the post.

Update: I just added a fix (in code below and the Service download) for making sure that footnote reference titles aren’t duplicated if you have existing MultiMarkdown-formatted footnotes in the document.

#!/usr/bin/env ruby
 
def e_sh(str)
	str.to_s.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\')
end
 
input = STDIN.read
 
footnotes = input.scan(/\(\*(.*?)\*\)/m)
existing = input.scan(/^\[\^fn(\d+)\]: /i)
counter = existing.empty? ? 1 : existing.uniq.sort[-1].join.to_i + 1
 
output = []
footnotes.each {|note| 
	output << {'orig' => note[0], 'title' => "fn#{counter}", 'footnote' => note[0] }
	counter += 1
}
 
o = []
output.each_with_index { |x,i| 
	o.push("[^#{x['title']}]: #{x['footnote'].gsub(/\n\n(\s*.)/,"\n\n\t\\1")}")
	input.gsub!(/\(\*#{e_sh x['orig']}\*\)/m,"[^#{x['title']}]")
}
puts input.strip + "\n\n#{o.join("\n\n")}\n"

I’m in San Francisco for an AOL Tech code jam right now, so I don’t have a lot of time to thoroughly test this. Please let me know about any bugs that need fixing.

If you’re in San Francisco and like coffee or beer, hit me up on Twitter. If you’re here for Macworld, then you’d better be at my “40 Tips in 40 Minutes” talk with David Sparks and Merlin Mann on Thursday!

Related posts:

1. A better System Service for Evernote clipping — with MultiMarkdown
2. Auto-convert your inline Markdown links to references
3. A System Service for to. url shortening

Originally posted on BrettTerpstra.com at A Service for writing MultiMarkdown footnotes inline

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

If you’ve taken off with KeyBindings already and your file wildly diverges from mine, the script is available for use by anyone. It requires a certain format in the file (I built it specifically for my own needs), but a little modification and you should be able to generate quick cheat-sheets for your own bindings.

You can find the script in the KeyBindings repo (it’s called document_keybindings.rb). You’ll want to modify the various sections of the output, so you’ll need to know a little Ruby to dink around with it. It’s not a bulletproof script by any means, but if you know a few regular expressions and some basic logic you’ll be able to make it do what you want. Note that by default it reads from “DefaultKeyBinding.dict” in the same directory as the script, and writes out to “readme.md” (in the same directory).

.dict file format

The basic comment/command format is:

// > defaults write -g NSTextKillRingSize -string 6
// replace yank: command with yankAndSelect for use with the kill ring
"^y" = (yankAndSelect:);

• Lines beginning with “// >” are added as parenthetical notes to the next command’s description
• Lines beginning with “// TODO” are ignored
• The description of the command comes before the line it’s defined on
• I doesn’t handle free-spaced commands yet, command definitions should be on a single line (for now)

Groups are defined similarly:

"^@c" = { // Commenting commands
  // comment with "//"
  "/" = (setMark:, moveToBeginningOfParagraph:, insertText:, "// ", swapWithMark:, moveRight:, moveRight:, moveRight:);
  // comment with "#"
  "\\" = (setMark:, moveToBeginningOfParagraph:, insertText:, "# ", swapWithMark:, moveRight:, moveRight:);
};

• The title of the group is on the same line as the starting bracket
• Commands within the group will be prefixed with the group’s key combination in the output

Any top-level commands (not in a group) will be gathered and output at the top of the output. You can modify the script to title that table any way you like.

The output table is currently in MultiMarkdown format but converted to HTML (using /usr/local/bin/multimarkdown, so you’ll need that installed) before writing to the ‘readme.md’ file. You can change or remove all of the prefixed verbage just by editing the INTRO variable.

Hopefully this will help keep things cleaner and minimize the number of explanations I have to send out in emails. Something about sharing a complicated trick and then modifying the steps without updating the documentation seems to throw people off. Fancy that.

Related posts:

1. An average morning
2. Introducing the Marked Bonus Pack
3. KeyBinding madness

Originally posted on BrettTerpstra.com at A little KeyBinding sanity

“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

This next geeklet is quite similar to the Top CPU Processes geeklet I last shared. It finds the apps and processes with the biggest memory footprint on your system and lists the top 10. The output looks like:

Top RAM processes

WebProcess       926.62M
Mail             360.05M
Safari           211.48M
iTunes           206.38M
Finder           180.80M
Skype            143.15M
WindowServer     137.12M
LaunchBar        135.71M
mds              118.14M
Reeder           117.47M

It includes system-level processes, too, so you can see if something other than your running apps is taking up RAM. Keep in mind that RAM is meant to be used, and having it filled up only starts to slow down your system when it has to page it out constantly. That being said, if your system is slowing down, this overview can give you a quick idea what’s happening.Here’s the full code. Copy and paste it into a file called memmeter.rb, save it and run chmod a+x /path/to/memmeter.rb. Then set up your shell geeklet to run /path/to/memmeter.rb and you should be good to go.

#!/usr/bin/ruby
 
def bytesToMeg(bytes)
	if bytes.to_i > (1024*1024)
		bytes = (bytes.to_f/1048576)
		bytes = (bytes * 10**2).round.to_f / 10**2
		bytes = bytes.to_s + '0' if bytes.to_s =~ /\d+\.\d$/
		'  ' + bytes.to_s + 'G'
	else
		bytes = (bytes.to_f/1024)
		bytes = (bytes * 10**2).round.to_f / 10**2
		bytes = bytes.to_s + '0' if bytes.to_s =~ /\d+\.\d$/
		bytes = ' ' + bytes.to_s if bytes.to_s.length == 5
		bytes.to_s + 'M'
	end
end
 
def spacer(string)
	if string.length > 15
		string = string[0 .. 12] + "…  "
	else
		spaces = 16 - string.length
		0.upto(spaces) do
			string += " "
		end
	end
	string
end
 
input = %x{ps -arcwwwxo "command rss" -m}
counter = 0
total = 0
 
title = ARGV[0] == "-t" ? ARGV[1] : "Top RAM processes"
print "#{title}\n\n" unless ARGV[0] == "-t" && ARGV[1].nil?
 
input.each {|line|
	if line =~ /^(.*?)\s+(\d{4,})$/
		exit if counter == 5 or total == 10
		puts "#{spacer($1)}#{bytesToMeg($2)}"
		if $2.to_i < 1
			counter += 1
		end
		total += 1
	end
}

Just like the Top CPU Processes script, you can call it with memmeter.rb -t "Title to display", or just -t to display no title. If no parameters are given, it will display “Top RAM Processes.”

Next up, either a good system status overview script or some network status geeklets. Whichever my geek muse picks first, I suppose.

Related posts:

1. Geeklet: Top CPU processes
2. Geeklet: 1-minute average CPU load
3. Quick Tip: throttling parallel batch processes in Terminal

Originally posted on BrettTerpstra.com at Geeklet: Top RAM Processes

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

Geek it up

To make this a little geekier: if you’re doing this in nvALT, you can right click the note in the list to copy a URL. Then create a wwid (what was I doing) alias in your .bash_profile:

alias wwid='open nvalt://find/YourNoteURL'

Now you can access that note directly in nvALT from the Terminal with wwid. You can also put that bookmark on a hotkey using any of the various keyboard shortcut apps. Alternatively, if you’re using a plain text file without nvALT, just create an alias or AppleScript to open it in your favorite editor…

No, seriously. Geek it up.

Given my love for the command line, it’s unsurprising that I wrote a little script to work with this system. You can, of course, get the full contents of the note with QuickQuestion (qq doing). Because I added a “later” section and wanted to clean up the output, I created a second method. My input file (?? What was I doing.md) looks like this:

@(whatiwasdoing)
Currently:
    - 2011-11-03 20:22 | something entirely different
    - 2011-11-03 20:19 | something I've been working on for a while now
Later:
    - stuff I intend to come back to and am not ready to delete yet
    - this part of the file is ignored by the `doing` script

You can leave that line blank or add your own tag, but there needs to be a line before the “Currently” project starts (the script inserts all new entries at the third line, so it would get weird if that wasn’t the first line of the section, right?). The script also expects the entries to be tabbed in and the project headings to be flush left. The Later section can have any name, or not be there at all. It’s ignored by this script.

Here’s the script¹ with no comments and no explanation²:

DOINGFILE="/Users/ttscoff/Dropbox/Notes/nvALT2.1/?? What was I doing.md"
 
if [[ $# -eq 0 ]]; then
  awk '{\
  if (currently==1)
    if (match($0,/^[^\t]/))
      currently=0
    else {
      if ($0 !~ /@done/) {
        sub(/^[ \t]+/,"")
        print
      }
    }
  else
    if (match($0,"Currently:"))
      currently=1
  }' "$DOINGFILE"
else
  input="$@"
  head=`awk 'NR < 3' "$DOINGFILE"`
  tail=`awk 'NR > 2' "$DOINGFILE"`
  datestamp=`date +'%Y-%m-%d %H:%M'`
  echo -e "$head\n\t- $datestamp | $input\n$tail" > "$DOINGFILE"
fi

Just paste this into a file and save it in your path as “doing”. Set the DOINGFILE variable to the path to your note. Lastly, run chmod a+x /path/to/doing to make it executable.

If you run the script with no arguments, it will spit out the “Currently:” section of the file (requires that there be a “Currently:” section of the file). I’d get this from the input file above:

$ doing
- 2011-11-03 20:22 | something entirely different
- 2011-11-03 20:19 | something I've been working on for a while now
$

If you run it with an argument, it takes it as a new entry, adds a timestamp and inserts it at the top of the Currently section.

$ doing "something I've always wanted to do"
$ doing
- 2011-11-03 20:35 | Something I've always wanted to do
- 2011-11-03 20:22 | something entirely different
- 2011-11-03 20:19 | something I've been working on for a while now
$

You have to manually edit the file to remove old entries or mark things completed, but the script is a handy means of input. You can interface it with LaunchBar fairly easily, too, if that fits your workflow better. Once you’ve set up the doing script, just create an AppleScript at ~/Library/Application Support/LaunchBar/Actions/Doing.scpt and paste this into it:

-- Right click and Copy URL in NV or nvALT to get this
property notelink : "nv://find/%3F%3F%20What%20was%20I%20doing/?NV=Hd9WpOVTTtuY3Zu6gljYVA%3D%3D"
 
on handle_string(message)
  -- get the input from LaunchBar
  if message is "?" then
    -- if the input is just "?" display the script response
    set _doing to do shell script "/Users/ttscoff/scripts/doing"
    tell application "LaunchBar" to display in large type _doing
  else if message is "e" or message is "edit" then
    -- if the input is just "e" or "edit", open the nvALT note link
    -- if you're not using nvALT, replace this with a command to open 
    -- your note in your preferred editor
    open location notelink
  else
    -- otherwise, create a new entry using the input
    do shell script "/Users/ttscoff/scripts/doing \"" & message & "\""
  end if
 
end handle_string

In LaunchBar, type ‘doing’ to select the action and hit the spacebar. Type in your entry and hit return. The timestamp will be added by the script, and the netry will be inserted at the third line of your file. If, in the LaunchBar’s text field, you type just a question mark (?), you’ll get a heads-up display of your current entries. Typing just “e” or “edit” will open the link you set up at the top of the script.

There you go. Now you know what I think is keeping me sane and are simultaneously questioning my sanity.

Related posts:

1. An average morning
2. A Service for writing MultiMarkdown footnotes inline
3. A System Service for to. url shortening

Originally posted on BrettTerpstra.com at Scatterbrains 2: The geekening

I’ve been having an issue with the latest version of Growl (1.3.1) where notifications randomly get “stuck.” No amount of clicking and option-clicking will make them go away. Until there’s a fix for this, I’m using a brute force restart to clear them¹. I have it set up as an alias (killgrowl) in my .bash_profile and as a LaunchBar action (Restart Growl.scpt). It’s a really simple command:

killall Growl && open -a Growl

And in an AppleScript in ~/Library/Application Support/LaunchBar/Actions/Relaunch Growl.scpt

do shell script "killall Growl && open -a Growl"

Easy enough, right? You could run the AppleScript from any launcher (e.g. FastScripts), too. Like I said, brute force and lacking in any elegance, but it’ll get me through until a fix comes out.

Related posts:

1. Clear sticky Growl notifications with a keyboard shortcut
2. nvALT 1.0.5 (quick fixes)
3. Quick tip: AppleScript application toggle

Originally posted on BrettTerpstra.com at Quick Tip: Quickly clear stuck Growl notifications

Ok, I made something interesting (to me) last night. It’s probably not worth taking the time to write up, but someday someone might find it and think it useful. I apologize for the messiness of the code, if I take this further and clean it up, I’ll update this post.

I was working on a few text-analysis features for Marked and decided I wanted to be able to show repeated words on a per-paragraph basis. The following is the experiment I did as a proof-of-concept. I decided that I wanted to do this in JavaScript/jQuery for various reasons, so my existing Ruby scripts were mostly useless. Thus, I devised a way to handle it entirely in a WebKit browser.

Demo

For the purposes of demonstration, I set up a single-page, dynamic version of this. You can enter any article URL and see the processing take place. Hover over a bolded word to see where it repeats in the paragraph. Note that it’s pulling through a proxy of Marky the Markdownifier, and that some markup will return blanks. Obviously, it also helps to have a lot of text in the article you’re analyzing. Hard up for ideas? Try this, or this. Give it a few seconds to load, it pulls in the content in the background and I haven’t put a progress indicator on it yet.

Breakdown

I started with a Porter Stemmer using a script from tartarus.org. Stemming allows you to break a word down to a root form, so that all variations of a word can be boiled down and plurals, conjugations and various anomalous representations of a word will all match each other. From there, I do a frequency check to find word roots used more than once within the block being processed, creating an array of the repeated words. Then I re-parse the block, one word at a time, adding some markup to words whose root is found in the previously-created array.

Here’s the main script with a few comments. Until I get this prettied up, I won’t go into a step-by-step. Feel free to lift and improve as you like. Remember to include the porter-stemmer script before this script. Oh, and because I’m lazy, you’ll need to include jQuery as well. The in_array function is stolen from php.js.

// from php.js
function in_array (needle, haystack) {
  for (key in haystack) {
    if (haystack[key] == needle) {
      return true;
    }
  }
  return false;
}
 
// short, common words to skip when counting
var stopwords = ['1','2','3','4','5','6','7','8','9','0','one','two','three','four','five','about','actually','always','even','given','into','just','not','Im','thats','its','arent','weve','ive','didnt','dont','the','of','to','and','a','in','is','it','you','that','he','was','for','on','are','with','as','I','his','they','be','at','one','have','this','from','or','had','by','hot','but','some','what','there','we','can','out','were','all','your','when','up','use','how','said','an','each','she','which','do','their','if','will','way','many','then','them','would','like','so','these','her','see','him','has','more','could','go','come','did','my','no','get','me','say','too','here','must','such','try','us','own','oh','any','youll','youre','also','than','those','though','thing','things'];
 
// takes the text of a paragraph element as input
// returns marked up text with repeated words in 'b' tags with a class matching their "stemmed" root
function checkWords(input) {
 
  var words = input.split(' ');
  var wordcount = {};
 
  // build an object to count word frequency
  $.each(words,function(i){
    thisWord = String(this).replace(/[\/\\]/,' ').replace(/’/g,"'").replace(/[^a-z' ]/gi,'').toLowerCase();
    if (!in_array(thisWord,stopwords)) {
      var word = stemmer(thisWord);
      if (wordcount[word] > 0 && word.length) {
        wordcount[word] += 1;
      } else {
        wordcount[word] = 1;
      }
    }
  });
 
  // convert the object to an object array
  // include only words repeated more than once within the paragraph
  var topwords = new Array();
  $.each(wordcount,function(w,i){
    if (i > 1)
      topwords.push({'word':w,'freq':i});
  });
 
  // convert the object array to a flat array
  topwordsArr = new Array();
    $.each(topwords,function(i) {
    topwordsArr.push(String(this['word']));
  });
 
  // re-parse the output, marking up repeated words based on their stems
  var output = '';
  $.each(words,function(w) {
    var aWord = String(this);
    var stripWord = stemmer(aWord.replace(/[\/\\]/,' ').replace(/’/g,"'").replace(/[^a-z' ]/gi,'').toLowerCase());
    if (in_array(stripWord,topwordsArr))
      output += ' <b class="'+stripWord+'">'+aWord+'</b>';
    else
      output += ' '+aWord;
  });
  return output;
}
 
(function($){
  // grab common top-level elements
  grafs = $('p,ul,ol,blockquote,h1,h2,h3,h4,h5,h6,pre code',$('#content'));
  // navigate each element found
  $.each(grafs,function(a,g){
    // if it's a paragraph, we'll process it
    if (grafs[a].tagName == "P") {
      $('#work').append($('<p>').html(checkWords($(grafs[a]).text())));
    // if not, we just stick it back into the DOM
    } else {
      $('#work').append(grafs[a]);
    }
  });
  // set up hover listeners on the 'b' elements
  // the class is pulled from the hovered element
  // all similar words are highlighted on hover
  $('b','#work').hover(function(){
    var thisClass = this.className;
    $('.'+thisClass).addClass('highlight');
  },function(){
    $('.highlight').removeClass('highlight');
  });
})(jQuery);

This little bit of css will add the highlighting and a nice fade in compatible browsers:

b {
  font-weight:bold;
  -webkit-transition:color .2s ease-in-out;
  -moz-transition:color .2s ease-in-out;
  -o-transition:color .2s ease-in-out;
  transition:color .2s ease-in-out;
}
.highlight { color:rgba(207, 95, 205, 1);}

If I decide to include this in Marked, it will definitely get some revamping. Like I said… proof-of-concept. Check out the demo, though, it’s kind of neat.

Related posts:

1. A simple but handy Bash function: console
2. Ampersands & Javascript
3. Quick Tip: This command line trick is tops

Originally posted on BrettTerpstra.com at Word repetition checking with JavaScript

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

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

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

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

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

Case-insensitive completion of running app names

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

In .app_completions is this function and complete command:

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

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

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

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

source ~/.app_completions

Bonus: kill ‘em all.

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

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

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

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

Related posts:

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

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

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

The Bonus Pack currently includes scripts and commands for interacting with Marked from TextMate, Sublime Text 2, Emacs and Vim, as well as a System Service and AppleScript for opening the current file from Byword, TextEdit, Notational Velocity/nvALT and a fallback for just about any AppleScript-able application.

Once everything is smoothed out to my satisfaction, the Service will likely be included as part of the Marked application, but for now it’s a separate download. The next version of Marked (1.3) is in final beta testing with a few Snow Leopard bugs left to squash. I should be submitting it to the Mac App Store within the week.

Version 1.3 updates to the latest MultiMarkdown build, adds Lion Fullscreen, opens any file extension, handles multiple custom styles, adds a few nice touches (including MathJax) to previews and more. I’m really excited about it, I just want to make sure that all of the new features don’t bring an equal number of new bugs with them.

One feature I’m especially excited about in 1.3 is the ability to watch a custom style’s CSS file in addition to the Markdown (or HTML) file you’re editing. Not only does this make creating custom styles much easier, it also opens Marked up to being to web designers what it already is to Markdown writers: a live preview for your HTML/CSS, no matter what editor you’re working in. HTML5/CSS3 compatibility combined with the custom processor (which can be set to run the file through Ruby or PHP, too) makes it a handy addition to a web development toolkit. I’m using it to design a revamp to the Marked website right now, in fact.

If you haven’t checked out Marked yet, take a look at the Marked website. I went overboard collecting all of the nice things people were writing and made the page pretty ugly with the press section, but I’m working that out right now. I promise.

Related posts:

1. Introducing the Marked Bonus Pack
2. Marked Bonus Pack 1.2
3. Get Marked: 50% off for Black Friday

Originally posted on BrettTerpstra.com at Marked Bonus Pack fix and Marked 1.3 progress

Continuing the series of geeklets I’ve been posting for GeekTool and NerdTool¹, here’s my “Top CPU Processes” monitor.

This geeklet is pretty useful. It’s effectively like running top on your desktop (but without the overhead) to see what processes are currently taking up the most cycles on your CPU. It works best in combination with a 1 minute CPU load monitor. I set this geeklet to update every 5 seconds. Within 5 seconds, things can change a lot, but any process that is taking up a significant portion of the current load will generally stay at the top and offer a clear idea of what might be slowing things down. It generally keeps running when other things start hanging, so it’s much more convenient than using Activity Monitor or top at the command line.

The script parses the ps command (process status, information about all of your processes). It uses the arguments ps -arcwwwxo "command %cpu" to display all processes (including other users’ and processes without terminals) by their executable name, sort by CPU and limit the columns in the output to just the command name and CPU percentage. That handles the bulk of the work right there. The rest of my script simply pulls out the top processes, limiting the number to 10 and cutting it short if there are more than five processes listed at 0%.

It color codes the output based on percentage, giving you red, yellow and blue lines if processes are above 10%, 20%, and 30%, respectively. It also justifies the output, truncating the process name if necessary and adding the percentage in parenthesis with a stretched space to right justify them. In order for the justification to work, you need to use a monospaced font such as Menlo or Droid Sans Mono (Inconsolata looks pretty good, too).

The script accepts one command line argument: -t "title". If you leave that off, it will automatically put “Top CPU processes” and a newline at the top of the output. If you add -t without an argument after it, it will remove the title entirely. If you use -t "Custom title" it will replace the default with your custom title (and automatic newline). Any other customization (colors, removing justification) will require manually editing the script. You’re on your own for that.

Here’s the script in its entirety. Just copy and paste it into a file called cpumeter.rb, place it in a script folder and make it executable (chmod a+x cpumeter.rb). Add the path to it as a shell geeklet and you’re good to go. In NerdTool, you may need to specify that the output is colorized.

#!/usr/bin/ruby
 
RED = "\033[31m"
GREEN = "\033[32m"
YELLOW = "\033[33m"
BLUE = "\033[34m"
MAGENTA = "\033[35m"
CYAN = "\033[36m"
WHITE = "\033[37m"
DEFAULT="\033[0;39m"
 
def spacer(string)
	if string.length > 15
		string = string[0 .. 12] + "…  "
	else
		spaces = 16 - string.length
		0.upto(spaces) do
			string += " "
		end
	end
	string
end
 
input = %x{ps -arcwwwxo "command %cpu"}.split("\n")
counter, total = 0, 0
 
title = ARGV[0] == "-t" ? ARGV[1] : "Top CPU processes"
print "#{title}\n\n" unless ARGV[0] == "-t" && ARGV[1].nil?
 
input.each {|line|
	if line =~ /^(.*?)\s+(\d{1,3}[\.,]\d)$/
		exit if counter == 5 or total == 10
		score = $2.to_i
		color = case score
		   when 0..10 then DEFAULT
		   when 11..20 then CYAN
		   when 21..30 then YELLOW
		   when 30..200 then RED
		   else RED
		end
 
		puts "#{color}#{spacer($1)}(#{$2})\033[0m"
 
		counter += 1 if $2.to_i < 1
		total += 1
	end
}

Updated to work with non-US systems

Next up, the same type of system monitor, but for physical memory size.

Related posts:

1. Geeklet: Top RAM Processes
2. Geeklet: 1-minute average CPU load
3. Quick Tip: throttling parallel batch processes in Terminal

Originally posted on BrettTerpstra.com at Geeklet: Top CPU processes