It’s a little shaky, especially on sites with bad markup. I’d say that right now it has about a 60% success rate. As I have time to work on it I’ll be improving this and adding a bevy of features that may eventually become an App Store submission. We’ll see. This proof-of-concept version¹, however, is free to download. I’ll ask nicely that you please not steal the idea and beat me to the punch.

This build is Lion-only; it won’t run at all on Snow Leopard. I’m not really taking any feature suggestions right now, as I already have an extensive roadmap for it that will turn it into something highly useful in many situations (and I’m quite aware of what it lacks in this state). I would enjoy hearing from you with your reactions, though.

Credit due

This version uses GGReadability by Curtis Hard. You should definitely check out his work-in-progress app, Caffeinated. It’s an RSS reader with Google Reader support and some serious potential. I’m also using HTML2Text for “markdownifying.”

Enjoy.

Download

Related posts:

1. Introducing the Marked Bonus Pack
2. Meet Marky, the Markdownifier
3. Instapaper Beyond Bugs (fixed)

Originally posted on BrettTerpstra.com at Introducing Gather, a Cocoa Markdownifier

As of recent versions, Notational Velocity and nvALT have a URL handler for nv:// (or nvalt://). Using the /find/ parameter allows you to initiate a search in NV from a link, e.g. nv://find/abnote%3AJohnny Appleseed. If you use a unique prefix and full name, you can pinpoint a single note without having to create a file or locate the note’s ID. The first time you click the link, it will open a search in NV, and pressing Return will create the note and begin editing. Once the note is there, it will locate it instantly the next time you click the link.

I’m using the prefix “abnote:” on my notes. This AppleScript will create the URL entry automatically from the selected entries’ first and last names, and you can edit the prefix in the script to be anything you like. Just save it as “Add NV Note.scpt” in ~/Library/Scripts/Applications/Address Book and it will show up in your script menu² when you’re in Address Book. You can run it on a bunch of entries (it’s not optimized to run on an entire large address book, though), or one at a time as you need it.

I wrote this on Lion. I honestly have no idea if it works on anything earlier. It might³.

The script

tell application "Address Book"
	set thePeople to the selection
	repeat with thisPerson in thePeople
		set theName to name of thisPerson as string
		make new url at end of urls of thisPerson with properties {label:"NV Note", value:"nv://find/abnote%3A" & theName}
	end repeat
	save
end tell

Related posts:

1. Address Book search and Skype from the command line
2. nvALT 2.1 in the wild
3. iOS App Review: Reading List

Originally posted on BrettTerpstra.com at Connecting nvALT and Address Book

For the command line savvy, the gist has been updated as well. Run it with “-h” to see all of the options. There’s even a progress bar in the terminal (default setting).

The big news, though, is that I have this working within Marked. The next version will be able to accept dropped Scrivener projects and provide a compiled preview that updates with changes from Scrivener. No external application needed! That release should be ready relatively soon, I’m putting out a beta for testing this week.

For now, here’s the latest (and probably last) version of ScrivWatcher:

Related posts:

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

Originally posted on BrettTerpstra.com at ScrivWatcher, one more time

Just unzip the download below and put the app in your Applications folder (or wherever). Then drop a Scrivener project on it and it will open the compiled file as a Marked preview and start watching. You can also launch the application and you’ll get a droppable window that you can drag Scrivener projects to, or put it in your Dock for easy access.

Let me know how it works. If everything’s groovy, I’ll be adding this and some other updates to the Bonus Pack as soon as possible. I’ll probably try to get droplets for the MarsEdit, nvALT, etc. watchers working as well. I present at Macworld | iWorld at 10am today, so that’s going to have to wait while I rehearse!

Changelog

1.3

• Script detects whether it’s running on the command line or in the droplet. If it’s on the command line, adds progress bar support for caching and concatenating.

1.2

• Error catcher for some XML parsing issues on more complex document structures
• Rewrote the whole system to cache textutil conversions and only update when the rtf version is newer than the text version. It can now handle files with many sections much, much faster.
• Turned off headline generation from page titles by default. If you want it back, you can edit the script inside the app bundle and set titles_as_headers to true. I’ll try to build a more external configuration for it soon.

1.1

• Watches project XML file so changes to sorting and order update the preview as well
• Names preview files based on project name to avoid overwriting other open previews
• Opens dragged document in Scrivener if it’s not already open

Related posts:

1. Preview a full Scrivener document in Marked, live
2. ScrivWatcher, one more time
3. Marked scripts: nvALT, Evernote, MarsEdit, Scrivener

Originally posted on BrettTerpstra.com at ScrivWatcher droplet, an easier live Scrivener preview

I took the script and ran with it this morning, switching it over to REXML parsing and adding in titles for sections and pages. The original script broke on a couple of my projects, but the recursive XML handler I set up fixes the issue.

To run it, you just need to save the script on your drive and make it executable (chmod a+x /path/to/scrivwatcher.rb). Then you can run /path/to/scrivwatcher.rb /path/to/YourProject.scriv. Marked will open automatically and changes will be reflected every time you save. To stop the script, you need to type Control-c in the terminal window you ran it from.

I’m going to try to wrap this into a droplet that you can just drop a Scrivener project on and launch both Scrivener and Marked with scrivwatcher syncing the two. Once I’ve determined whether that’s win or fail, I’ll update the Marked Bonus Pack with it. Yes, I will eventually find time to build this functionality into Marked, along with the rest of the Bonus Pack scripts.

The script is currently a gist on GitHub if you want to play with it. I’ll be updating the gist as I have time to clean it up and make a few things (much) more elegant. If you want to fork and help me out, it’s always appreciated!

Related posts:

1. ScrivWatcher droplet, an easier live Scrivener preview
2. ScrivWatcher, one more time
3. Marked scripts: nvALT, Evernote, MarsEdit, Scrivener

Originally posted on BrettTerpstra.com at Preview a full Scrivener document in Marked, live

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

Anyway, I polished them up a little and threw up a GitHub page for them. If you’re a web designer and you’re looking for an iOS-like popup style, they might be of use to you. You can see the demo, the markup and classes and download the CSS (and minified version) at http://ttscoff.github.com/popupsCSS/.

Late “I-forgot-to-mention” addendum: These styles were developed primarily with Marked in mind, meaning there are no non-webkit vendor prefixes I guess I put in prefixless and moz versions in my sleep again and they are not at all cross-browser tested. I’ll put up a more complete version when I get a chance. If you take matters into your own hands, please fork on github or send me your updates for inclusion!

Related posts:

1. Title track: Something Precious
2. Pinboard redesign experiment
3. TextMate drag command for Base64 encoding images

Originally posted on BrettTerpstra.com at iOS-inspired popup box CSS

Dayone uses a very simple XML format in separate files to store your entries. It’s easy to replicate the structure using a script, allowing you to directly generating your own Day One entries from any part of your workflow. I’m bypassing the dayone CLI and dropping the updates in directly for added flexibility. Don’t get me wrong, I absolutely love that Day One comes with a CLI, I just wanted to experiment around it.

I’m using the new iCloud support for sync, and this Service is built to work with that folder structure by default. The version below (and in the download) looks in “~/Library/Mobile Documents/” (where iCloud stores documents) for a folder containing the word “dayoneapp.” I don’t know offhand what the bizarre names of the folders indicate, but they differ between accounts, so we have to grep out the matching folder. Assuming your Journal is called Journal_dayone (default) and you’re using iCloud, you shouldn’t have to edit anything. If it doesn’t work, run this in Terminal and copy the resulting path into the “dayonepath” variable:

find ~/Library/Mobile\ Documents/ -name "Journal_dayone"

If you’re using Dropbox, you’ll just need to make a minor alteration to the “dayonepath” variable. Delete the line starting with “dayonedir” and hardcode the Unix (POSIX) path to the “entries” folder, located directly inside of the Journal.dayone bundle in your Dropbox root folder. It will most likely be /Users/[yourusername]/Dropbox/Journal.dayone/entries/ if you haven’t changed any defaults in Dropbox or Day One.

The service itself is available for download at the end of the post, or you can take the script below and home-roll your own in Automator. It should work out of the box, no need for ruby gems or symlinked CLIs.

The only configuration you may want to edit is the “starred” variable. This defaults to off because Services aren’t interactive and you probably don’t want to star every entry you clip. If you do, though, just change “starred = false” to “starred = true” and it will make your calendar look like a planetarium.

The Service will use /usr/bin/textutil to strip out any rich text artifacts. I’m not certain this is necessary, but I found that when clipping rich text I would lose all of my line breaks and indents. This seems to solve it. The script also looks for text with hard breaks and handles them Github-style, preserving breaks using Markdown line break syntax.

If you have Growl running, you’ll get a notification. To be polite, it checks for Growl before attempting any notifications. The check can be slow sometimes, though, so you may want to either remove the check if you always have Growl running, or remove the whole Growl section at the end if you don’t.

The script:

Here’s the script. The same script can be found in the Service download at the end by opening the .workflow file in Automator. You can easily customize/edit from there, so this is posted just for reference.

require 'time'
require 'erb'
 
def e_sh(str)
	str.to_s.gsub(/(?=[^a-zA-Z0-9_.\/\-\x7F-\xFF\n])/n, '\\').gsub(/\n/, "'\n'").sub(/^$/, "''")
end
 
input = STDIN.read
entrytext = %x{echo #{e_sh input}|textutil -stdin -convert txt -stdout}
entrytext.gsub!(/\n([^\n])/,"    \n\\1")
uuid = %x{uuidgen}.gsub(/-/,'').strip
datestamp = Time.now.utc.iso8601
starred = false
 
dayonedir = %x{ls ~/Library/Mobile\\ Documents/|grep dayoneapp}.strip
dayonepath = "~/Library/Mobile\ Documents/#{dayonedir}/Documents/Journal_dayone/entries/"
 
template = ERB.new <<-XMLTEMPLATE
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>Creation Date</key>
	<date><%= datestamp %></date>
	<key>Entry Text</key>
	<string><![CDATA[<%= entrytext %>]]></string>
	<key>Starred</key>
	<<%= starred %>/>
	<key>UUID</key>
	<string><%= uuid %></string>
</dict>
</plist>
XMLTEMPLATE
 
fh = File.new(File.expand_path(dayonepath+uuid+".doentry"),'w+')
fh.puts template.result(binding)
fh.close
 
growl_running = %x{osascript -e 'tell application "system events" to return (count of (every process whose bundle identifier is "com.Growl.GrowlHelperApp")) > 0'}
 
if growl_running
  %x{osascript -e 'tell application id "com.Growl.GrowlHelperApp" to register as application "Clip to Day One" all notifications {"Clip Complete"} default notifications {"Clip Complete"} icon of application "Day One"'}
  %x{osascript -e 'tell application id "com.Growl.GrowlHelperApp" to notify with name "Clip Complete" title "Log to Day One" description "Clipped to Day One" application name "Clip to Day One"'}
end

Side note: I mentioned to @brianstucki that this Service might contain the necessary ingredients for an Evernote-to-Day-One solution, but I’ve realized it’s really only the last part of the equation. What you’d probably want to do with most RTF/text notes is export HTML, extract the “created on” meta and parse it into the correct date format, then pipe the rest of the contents through markdownify_cli.php, passing the result to dayone new. Then you’ll have nice, Markdown versions of your notes from Evernote, preserving much of the formatting. I tested this, and it works pretty flawlessly for text notes.

Download

For complete instructions on installing the service (and adding a keyboard shortcut for it), see the how-to posted here.

Related posts:

1. Quick Tip: Quickly clear stuck Growl notifications
2. A System Service for to. url shortening
3. Updated: Songza Lucky Link Service

Originally posted on BrettTerpstra.com at System Service: Clip to Day One

Day One is a gorgeous app for keeping a personal journal. I discovered it, if I recall correctly, via David Sparks. It has iOS companion apps and iCloud syncing. It also has excellent search capabilities, likes MultiMarkdown and can export my entries to plain text at any time. I like it because it’s good-looking and concise; just what I need, with no feature bloat. Plus, it’s specifically designed to do exactly what I want: keep a timestamped journal of what I’m working on, have accomplished or have just discovered in my digital travels.

Day One already has a quick entry palette in the menubar. It also has a command line interface (/usr/local/bin/dayone)¹ which provides some geeky options (try dayone in Terminal) and the flexibility needed to replace my current logging system. You can create entries quickly with either method, but I wanted just a little bit more out of it. I built a quick script which allows a basic syntax for starring entries and defining dates (using natural language) inline in the entry itself. It can be used from the command line, from LaunchBar (or similar) and can be incorporated into just about any scriptable workflow.

The natural language portion of the script is built on the “Chronic” Ruby gem, so running this script as is requires that you have that installed. If you don’t have it available, just run gem install chronic to add the gem. If you run into errors doing that, try sudo gem install chronic and provide your system password. Here’s the script, complete with some explanation in the comments.

#!/usr/bin/ruby
 
# logtodayone.rb
# Brett Terpstra (http://brettterpstra.com)
# Use and modify freely, attribution appreciated
# 
# This script works with the Day One[1] command line utility
# It parses an input string for an exclamation point prefix to mark starred
# and/or a [date string] at the beginning to parse natural language dates
# 
# Requirements:
# Chronic ruby gem
#
# Example usage:
# logtodayone.rb "! This is a starred entry."
# logtodayone.rb "[yesterday 3pm] Something I did yesterday at 3:00PM"
# logtodayone.rb "! [-2 1:30am] A starred entry about something I did two days ago"
 
require 'rubygems'
require 'chronic' # (`gem install chronic`)
 
if ARGV.length > 0
  input = ARGV.join(" ").strip
else
  print "Log entry: "
  input = gets.strip
end
 
# If the input starts with an exclamation point, make it starred
starred = input =~ /^!/ ? "true" : "false"
# remove the bang from the input string
input = input.gsub(/^!\s*/,'')
 
# if there's a [date] specified, parse it
if input =~ /^\[(.*?)\]/
  datestring = $1
  # if the date starts with -X, assume it means X days ago
  if datestring =~ /^\-(\d+)/
    datestring.sub!(/\-(\d+)/,"\\1 days ago ")
  end
  # Replace a single 'y' within the date brackets with "Yesterday" for parsing
  datestring.sub!(/\by\b/,'yesterday')
  # Parse the resulting date string with Chronic
  d = Chronic.parse(datestring, {:context => :past, :ambiguous_time_range => 8})
  d = DateTime.now if d.nil?
else
  # if no [date] specified, make it right now
  d = DateTime.now
end
date = d.strftime("%m/%d/%Y %l:%M%p") # dayone formatted
input = input.gsub(/^\[.*?\]\s*/,'') # remove [date] from input
 
%x{echo "#{input}"|/usr/local/bin/dayone -d="#{date}" -s=#{starred} new}

Some usage tips

You can star an entry by beginning it with an exclamation point. I’m not sure how I’ll use stars yet, but I figured the option was there, so I’d add a syntax for it.

I often end up logging things after the fact but before I forget what I was doing, so it’s important for me to be able to enter an approximate date and time for the sake of organization. Date strings are entered in square brackets at the beginning (or after an exclamation point) of the entry. The natural language accepts basic strings such as “yesterday 3pm” or “noon” and converts them to Day One-compatible dates. It also accepts “-X” operators to specify a number of days ago (I’m assuming I won’t be logging entries in the future). “y” by itself will be converted to “yesterday.” A typical entry for me would look like “[y 11:45pm] working on silly scripts for logging to Day One.” An entry with no exclamation point and no date brackets is just read as a normal entry at the current time.

I’m using generic @tags–a habit carried over from my VoodooPad scratchpad–to make my entries easily searchable by topic or project. Beyond that, I’m just relying on Day One’s built-in chronological organization and full-text search.

The script is all fine and good, but it’s not much use if it’s not convenient to access. Here are a few of the ways I’m making it universally accessible in my workflow.

Bash alias

First things first, lets make it really easy to log entries from the command line. A simple alias in your ~/.bash_profile shortens things up:

alias log="~/scripts/logtodayone.rb"

Now you can make an entry with log "the thing I was just doing".

LaunchBar Action

Given that few of us are always on the command line, it would be nice to access the script easily from other utility apps. I personally use LaunchBar, but you can create similar scripts for Alfred, Quicksilver, etc. If you use LaunchBar, you can just save the three-line script below as Log to Day One.scpt in ~/Library/Application Support/LaunchBar/Actions:

on handle_string(message)
  do shell script "/Users/ttscoff/scripts/logtodayone.rb \"" & message & "\""
end handle_string

Now, just pop up LaunchBar and type ldo or similar to select the action, then type space to get a text field where you can type your log entry. The script syntax applies in full, so start with an exclamation point to star the entry, and use natural language date syntax between square brackets to specify a date, if needed.

Git commit wrapper

I do something similar to this with an nvALT note, so I thought I’d try it with Day One for a while. It’s a basic bash function to copy a note from a git commit into my daily log. It just wraps git -am (commit all, message), so more complex commit commands won’t work. It covers 90% of the commits I’d actually want in my journal, though.

function cdo(){
  msg=$*
  path=$(pwd)
  ~/scripts/logtodayone.rb "@${path##*/} $msg"
  git commit -am "$msg"
}

Update: I made the git wrapper significantly smarter, thanks to a little assist from @nnutter. It basically parses up your git tree for the actual repo name instead of using the directory name you’re currently in.

# experimental wrapper for git to log commits to Day One
# lots of credit to http://nnutter.com/2012/01/git-todo/
function cdo(){
  msg=$*
  GIT_DIR=$(git rev-parse --git-dir)
  if ! (( $? )); then
      GIT_DIR=$(echo "$GIT_DIR" | awk -F/ '{nlast = NF -1;print $nlast}')
      if [ -z "$GIT_DIR" ]; then
                path=$(pwd)
                GIT_DIR=${path##*/}
      fi
            ~/scripts/logtodayone.rb "@$GIT_DIR $msg"
  fi

  git commit -am "$msg"
}

So that’s my fiddling for the evening. Back to doing something more useful (like preparing for my Macworld | iWorld talk with Merlin Mann and David Sparks).

Related posts:

1. System Service: Clip to Day One
2. VoodooPad log navigation plugins
3. Scatterbrains 2: The geekening

Originally posted on BrettTerpstra.com at Logging with Day One, geek style

I wanted to share a handy tool that I realized I use daily but rarely talk about. I call it Read2Text, but it’s really just a Frankenstein script which combines Python Readability (license) with html2text (license). The combination allows you to grab web pages, process them with a port of Arc90’s Readability and convert the HTML to Markdown, ready for pasting or piping to a text file.

nvALT has this built in, but it’s been a little crashy lately. I find it more reliable to just do this from the command line. If you install it in your path (both the read2text script and the “readability” folder), you can run read2text http://brettterpstra.com/keybinding-madness/ | pbcopy.

You’ll get a Markdown-ified version of the page, with links, image links, headers, code blocks and text intact, but no comments, sidebars, ads, etc. It’s not perfect, but it does a solid job and cleanup only takes me a minute, even on huge sites. I use this most of the time instead of clipping to Evernote these days.

I alias it in my .bash_profile to rtt, and often redirect the output straight to a text file in my nvALT folder: rtt http://grml.org/zsh/zsh-lovers.html > ~/Dropbox/Notes/nvALT2.1/zsh\ lovers.md

Now I have a new note that automatically shows up in nvALT with the text of the zsh-lovers page (yeah, I tried switching to zsh this morning. I’ll have to come back to that). Anyway, I thought others might find this hack of use, so I’m making the download available below.

By the way, I also have a web service for this. You can get raw markdown or a nice interface for previewing and copying. There’s also an API and bookmarklets for integration into your favorite browser. Have fun!

Related posts:

1. Meet Marky, the Markdownifier
2. nvALT 1.0.8 progress
3. Clippable

Originally posted on BrettTerpstra.com at Scripting Readability and Markdownify for clipping web pages

Well, here it is: my last Geeklet post of 2011. I think it’s the simplest Geeklet I have, but it’s kind of fun. It uses the I ♥ Quotes API to put a random quote on your desktop.

There’s a variety of quote categories to choose from, ranging from geeky to humorous, religious to sci-fi. See the API page for a list and replace “literature” in the url with whatever you like. You can pull from multiple categories by separating them with a “+” in the url. There’s even a simpsons_chalkboard category to play with.

Here’s the one-line command that you can stick right into the Geeklet/Nerdlet without worrying about a shell script (Updated: I added some more awk fun to the end to rewrap the output while preserving the break before a “– Author” attribution):

curl -s 'http://www.iheartquotes.com/api/v1/random?max_lines=5&source=literature+macintosh'| \
grep -v "http://iheartquotes"| \
sed -e 's/\&/\&/g'|sed -e 's/"//g'| \
awk '{printf "%s ",$0} END {print ""}'|awk -F"--" -v OFS="\n\n—" ' $1=$1'

You should remove the “\” and newline at the end of each line (putting it all on one single line).

The first part (before the first pipe) just uses curl to grab a random quote from the “literature” section of the Quotes site (the -s makes it operate “silently” with no additional feedback). The url query parameters limit the quotes to a maximum of two five¹ lines, just to maintain a somewhat consistent length and make it easier to set up fonts and styles. The result of the API call is sent to grep -v to remove the credit line at the end of the response, and then on to sed for a little typographic cleanup (replace quote entities and convert double hyphens to an em dash). The two awk statements at the end will first remove any line breaks, and then, if there’s a double-hyphen (which almost always means an attribution line in these API responses), it adds a double newline and converts that to an em dash².

Have fun with it, and have a Happy New Year!

Related posts:

1. Geeklet: 1-minute average CPU load
2. Geeklet: Top RAM Processes
3. Geeklet: Top CPU processes

Originally posted on BrettTerpstra.com at Desktop Quotes Geeklet

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

Markdown QuickTags, my WordPress plugin which adds a massive number of Markdown-editing features to the built-in post/page editor had broken with the release of WordPress 3.3. Basically, the quicktags.js file which generates the buttons in the HTML editor changed completely. For the better, of course, but that’s what Markdown QuickTags (hackishly) overrides to work its magic, and the change pulled the rug out from under the plugin. I had to rewrite a good portion of the JavaScript, and it took me a while just to figure out what was going on, but it’s back in action. I’m writing this post with it right now.

I added some new font options (served via Google Fonts), more size choices and a live editor preview from the settings page. I’m working on adding a few “themes” to the editor and making it a little more customizable, but it’s lower on my list than things like, um, working.

Eventually I’ll make a video of it in action, I think I’ve probably snuck in a few features that I’ve done a poor job of documenting, anyway. I revamped the look this time, too (much more Byword–esque) so a screenshot refresh is in order as well. But that’s for after Christmas.

Happy Holidays, hope you’re all having great times.

If you write in Markdown and use WordPress, you’d be insane not to try this out. Version 0.8 just became available in the WordPress Plugin Repository.

Related posts:

1. Markdown QuickTags: WordPress plugin for Markdown lovers
2. Markdown QuickTags 0.7
3. Markdown QuickTags makes 1000 people happier and more attractive

Originally posted on BrettTerpstra.com at Markdown QuickTags 0.8 for Christmas

It’s showing its age (I’ve come to loathe the design), but the site I’m talking about is the Blogsmith Bundle Documentation site. Peek around, you’ll see how easily everything gets cross-linked and how quickly you can navigate a fair amount of information. Keep in mind that you can make a VoodooPad site look any way you please, don’t judge the possibilities based on my aging design.

Why would you want to do this? Once you get the pieces in place (it’s no more complicated than any other ground-up website build-out), it’s a great way to statically generate up-to-date content. It’s easy to make changes to existing content and update the live site with the click of a button, plus VoodooPad is flexible enough to allow for separate testing and production output. Page links are always current and automatically update as you change things around, and the Wiki-linking features of VoodooPad make it great for reference content. Which leads to the second question…

What kind of website is right for this? Well, if it makes a good VoodooPad document, and doesn’t need to do anything terribly dynamic, it’s probably a good candidate. Remember that the output from VoodooPad is going to be flat (all in one directory), so if for some reason your proposed website requires a directory structure, you’d be better off building it another way. With that said, the flat structure has never been an issue for me; I do all of my organizing and editing in VoodooPad for this site, visual modifications are made in the template, I have automated scripts for pushing content live; I never actually touch the myriad files in that directory.

Read on for some nitty gritty…

Getting started

First, I built the whole notebook in plain text, using Markdown. VoodooPad does a pretty decent job converting Rich Text to HTML, but if you’re as picky about markup as I am, using Markdown on plain text is the way to go. There’s a Markdown plugin available in VoodooPad, but I really wanted to use MultiMarkdown to get tables, footnotes and more. Unfortunately, I didn’t find a way to make MultiMarkdown blend within the VoodooPad workflow, but I did find Python Markdown Extra, which turned out to be perfectly workable for this task. We’ll get to that in a second.

Notebook tips

1. Use plain text. Open your Document Info palette and have VoodooPad start each page as plain text. Wiki-links and everything will still work fine, and VoodooPad will render those to HTML when you export. No sweat. But we’re working in Markdown here, so avoid any of the Rich Text formatting capabilities of VoodooPad.
   • I’d also recommend you turn off Smart Quotes; our scripts will smarten your straight quotes into web-friendly entities on the way.
   • For Markdown, setting Tab to insert four spaces is a good idea in the Editing preferences as well.
2. Don’t use titles in the page. If possible, cover that in your template; it will help you consistently use titles as <h1> or <h2> headers in the same location on every page.
3. Use a default page template. Create a page called “NewPageTemplate” and put in any elements you’d like on every page. This will be called every time you add or link a new page. Mine’s blank, and all of my repeated elements are handled in my template. It’s just handy to not be erasing unnecessary clutter when you’re ready to write a new page.

Python Markdown

Installing and setting up Python Markdown gives you the ability to add classes, ids and other markup elements that will make actually designing a template a lot more fun. Python has an easy_install command, and you can run it to add Markdown Extra to your local library:

easy_install markdown

To make sure your Python path is set to include your site packages, ensure that there’s a PYTHONPATH line is in your .bash_profile:

PYTHONPATH=/Library/Python/2.7/site-packages...

Yours may be longer, but it needs to have that path (or a path for a different version) in it. On Snow Leopard I ended up having to symlink my 2.6/site-packages to the 2.5/site-packages directory due to some weirdness with my Python install and the way that VoodooPad looks for packages. On Lion and Python 2.7, though, it seems to run fine without any persuasion.

Now you’ve got the power of Markdown Extra for your web export. It’s very similar to MultiMarkdown/PHP Markdown Extra, and has support for tables, fenced code blocks, code highlighting, footnotes and more. See the Python Markdown Extra homepage for syntax documentation, and be sure to browse the extra extensions available.

Special Pages

The Index

If you create a page called “index,” it will become “index.html” or “index.php” (depending on your settings in the export). Either way, this will become your home page. You can manually edit it, which is preferable in the case of a static website, or you can create scripts to generate lists of the latest content, etc. I’m using it to manage a static site, so I don’t have any dynamic content generators ready for you. You can take what I do have for some of the other scripted pages and modify… if you’re adventurous enough to be trying this out, you’re probably adventurous enough to brave some Python.

Creating a sitemap with excludes

I have a Sitemap script that runs whenever I load up a page tagged “sitemap” (there’s only one page with that tag, but you can see the possibilities).

Create a new page called “ScriptSiteMap” and add this code:

page = eventDictionary['item']
document = windowController.document()
if "sitemap" in page.tagNames():
  thelist = ""
  textView = windowController.textView()
  for key in document.keys():
    a_page = document.pageForKey_(key)
    if "excluded" not in a_page.tagNames():
      thelist = thelist + "* " + a_page.displayName() + "\n"
    page.setDataAsString_(thelist)

In your Event Scripts palette, add a new script under “Page opened.” Point it to “ScriptSiteMap.” Now create a blank page named Sitemap and tag it with “sitemap”. Whenever you load open that page now, it will generate a sitemap for the entire site. It can be slow once your site gets large, but you’ll want to open it after adding new pages and before exporting.

You’ll note that I have a line in scripts like this that looks like:

if "excluded" not in a_page.tagNames():

This way, I can exclude pages from being included in dynamically-generated content just by adding an “excluded” tag to the page. All of my scripts, notes, todo lists for the site, etc. are tagged “excluded” and don’t show up in any menus on the site.

Include a curated sidebar

You can include any page’s content in your template using the “#include” tag. This is handy for, say, a sidebar that you want to manually curate (or generate with a script). Just put the display name of the page into a tag like this in your template:

That’s it!

Adding Media

If you add the appropriate javascript (etc.) to your template, you can easily include video and audio in your site. Just put the straight markup needed into the page in VoodooPad and Markdown Extra will pass it through to your site. I actually embed movies directly in my VoodooPad document so they just output into the main folder, then I can include markup like this in a page:

<video id="movie" width="700" height="394" preload controls>
  <source src="optshift4.mp4" type='video/mp4; codecs="avc1.42E01E, mp4a.40.2"' />
  <source src="optshift4.ogv" type='video/ogg; codecs="theora, vorbis"' />
  <object width="700" height="394" type="application/x-shockwave-flash"
    data="flowplayer-3.2.2.swf">
    <param name="movie" value="flowplayer-3.2.2.swf" />
    <param name="allowfullscreen" value="true" />
    <param name="flashvars" value='config={"clip": {"url": "optshift4.flv", "autoPlay":false, "autoBuffering":true}}' />
    Download video as <a href="optshift4.mp4">MP4</a>.
  </object>
</video>

That creates a page like this.

Creating a custom template

The next thing you’ll want to tackle is a custom template. Find your “Web Export Plugins” folder at ~/Library/Application Support/VoodooPad/Web Export PlugIns and duplicate one that feels like a good start. You can always start from scratch once you understand the basics; working from a copy will ensure that you have all the building blocks to begin with. Right click on your copied template and “Show Package Contents” to open a new window and see what’s inside (or just head there in Terminal and open the whole folder as a project in your favorite editor).

For the most part, it’s just HTML, CSS and JavaScript (if you want), so have at ‘em. Just pay attention to the existing variables that will insert the rendered content. $page$ is the main one to be concerned with, but there are other variables available.

My output was originally all HTML, but I recently modified it to output PHP extensions and made my template use PHP to include a header and footer. This makes it really easy to make changes to the layout portions of the markup, as well as the linked scripts and styles, without having to re-export every time. I won’t go into detail, but if you know a little PHP, it should be easy to figure out.

I added some jQuery, and used animation, ColorBox and footnote hover bubbles¹. If you keep your scripts, css and images in subdirectories, copying them into your final export is a lot easier. You’ll find a postflight.sh script in your theme’s folder, and if you open it you’ll see where you need to specify what files to copy out with the export. Mine looks something like this:

#!/bin/bash
 
SRC_DIR=`cd "${0%/*}"; pwd`
cp -r "$SRC_DIR/images" "$VPWebExportOutputDirectory/."
cp -r "$SRC_DIR/scripts" "$VPWebExportOutputDirectory/."
cp -r "$SRC_DIR/css" "$VPWebExportOutputDirectory/."
cp "$SRC_DIR/favicon.ico" "$VPWebExportOutputDirectory/."

Web Export Script

Once you’ve got a template ready, it’s time to add some scripts to the document. I should warn you ahead of time that I’m still learning my way around Python. While these work, there may be more elegant ways to do this.

Create a page in my site document called “ScriptWebExport” that contains the following:

global re
import re
 
import markdown
import smartypants
 
# Grab the page from the current event (Web Export will markup page)
page = eventDictionary['item']
 
# Get the text of the page as a string
content = page.dataAsAttributedString().string()
 
# Remove some content before processing, in this case my todo items
output = re.sub(r'\[TODO\] .+', '', content)
 
# run the markdown module on the content, including or excluding any extensions desired
# you can just include 'extras' to get them all, instead of loading each individual extension
html = markdown.markdown(output, ['footnotes(PLACE_MARKER=+++footnotes+++)','headerid(level=2)','def_list','abbr','tables','fenced_code','codehilite'])
 
# return the Markdown Extra-processed page to be passed on for additional VoodooPad markup and linking
eventDictionary['itemMutableAttributedString'].mutableString().setString_(smartypants.smartyPants(html))

Now you just need to open up Window->Palettes->Event Scripts and add a new script under the “Web export will mark up page” trigger. Set it to the “ScriptWebExport” page and choose the Python interpreter. With a template ready and your Markdown Extra rendering, you’re ready to go.

Web Export

Now you’re ready to export. You can go ahead and test it out (File->Export Document->Web Export). Choose your template and pick a folder for the files. If you’re outputting php extensions, make sure you’re putting them somewhere you have php-enabled access to. Files with an html extension will load up in your browser no matter where you put them. VoodooPad exports your entire site “flat,” meaning it’s all in one directory. It’s easier this way, and since you’re doing all of the content management in the VoodooPad environment, you don’t really have to worry about it. Your theme can store includes, css, images and scripts in subdirectories.

This part is entirely optional, but I run a postflight script (set in the Web Export panel) that updates a git repository and pushes it to the live server after an update. I have two presets, one that pushes and one that doesn’t; deployment and development.

Here’s the script I use:

#!/bin/bash
 
cd "/path/to/my/export folder"
git ls-files -o | git update-index --add --stdin
git commit -am "Updating the VoodooPad website on `date`"
git push origin master

This does an automatic update and commits any files that have changed, were added or have been deleted. It’s a nice backup, too, just in case you exported something you weren’t ready for. Then I have a post-receive hook on the origin server that pushes out a copy of the latest changes to the web directory automatically.

You could accomplish much the same thing with Docksend in Transmit or just by outputting your documents to a mounted server folder. Have a preset for saving to a local folder for testing, and one for pushing to your remote folder in whatever way you prefer.

In Closing

Well, that’s my best shot at sharing what I’ve learned managing a website with VoodooPad. It’s not right for every situation, but it’s great for handling documentation and informational websites that change regularly and are well-suited for the kind of inter-page linking that VoodooPad makes so easy. I’ll be curious to hear if this sparks anyone’s imagination… can’t wait to see your site!

Related posts:

1. A Quick VoodooPad Script Plugin — Go To Today
2. VoodooPad log navigation plugins
3. How to be popular at parties

Originally posted on BrettTerpstra.com at Running a website with VoodooPad

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