Get it here, or wait for Sparkle to update it for you.

• Sidebar

  • TextMate does not load plug-ins until after the application is finished launching, which was causing problems when launching by double-clicking a project file (the project would open without a drawer or pane). This is now handled gracefully, but projects opened in this way will always have the drawer as they are opened before ProjectPlus is loaded.

• SCM Badges

  • Added support for Mercurial, Svk and Bazaar (these should be considered experimental – I don’t use them so please report issues)
  • Hopefully more to come, based on demand and how easy they are to implement
  • Since there are now quite a few, and some of them are expensive to have enabled (as all except SVN use shell execution), all of the SCM modules are disabled by default and you must selectively enable the ones you want
  • Fixed a memory leak that could occur when using SVN badging
  • Misc. performance improvements and bugfixes

• General:

  • Added Sparkle for automatic updates to future versions
  • Added an icon (thanks to Oliver Busch)
  • Other miscellaneous tweaks and improvements

Download.

Please report any issues you find at the new bug tracker.

Feature list:

• SCM status badges:

  • Support for SVN and Git
  • Displayed in the project file list and the window proxy icon

• Swapping the project drawer for a panel

  • Support for ⌃⌥⌘D and ⌃⌘R is kept
  • The sidebar can be placed on either side of the window
  • Since I created this someone has updated the MissingDrawer plug-in with these features, if you wish to use this plug-in instead then you can disable the feature

• Finder colour labels

  • Labelled files are displayed in the project drawer
  • Label can be set through the context menu

• Project-tree state can be preserved when re-opening the project

• QuickLook preview of files in the project file list through the context menu (or ⌥␣ when the file list is focused)
• Sorting options through the project file list context menu
• Display folders on top
• Sort by file extension
• “Open With” option

You should remove any conflicting plug-ins before installing, by deleting them from ~/Library/Application Support/TextMate/PlugIns.

Download ProjectPlus.

Get it here

Check out the Upcoming event page for all the details.

Let’s pretend we’re going to be writing some FAQ lists, so we’ll have a list of questions, like this:

This is the first question 
This is the second question 
This is the *third* question

<a href="faqlist.html#this-is-the-first-question">This is the first question</a>
<a href="faqlist.html#this-is-the-second-question">This is the second question</a>
<a href="faqlist.html#this-is-the-third-question">This is the third question</a>

To start, you’ll need to tell TextMate that the command needs to run with PHP, which is done with a shebang:

#!/usr/bin/env php 
<?php
//Our code will go here
?>

• Reading input (provided on standard input, and some information is given in environment variables)
• Processing the input
• Doing something with the result (generally either inserting some text into the current document, or showing a HTML window or tooltip)

So first we need to get the input from the document – if you look at the pop-up below the big text field you can see that the input for our command will come from the current selection (or the entire document if there is no selection). This is perfect for what we want.

We need to read the selection from standard input, the easiest way to do this is with:

$input = file_get_contents('php://stdin');

$filename = $_ENV['TM_FILENAME']

$lines = explode("\n", $document); 
foreach ($lines as $index => $line) { 
  $link = preg_replace('/\W+/', '-', strtolower($line)); 
  echo "<a href=\"$link\">$line</a>\n"; 
}

foreach ($lines as $index => $line) { 
   $tabstop = $index + 1; 
   echo '<a href="$filename#${' . $tabstop . '/\W+/-/g}">' .
      '${' . $tabstop . ':' . e_sn($line) . '}</a>' . "\n"; 
}   


// escape text for use in a TextMate snippet 
function e_sn($str) { 
   return preg_replace('/[$`\\]/', '\', $str); 
}

This will echo some lines like

<a href="#${1:/\W+/-/g}>${1:title}</a>

Which is TextMate’s syntax for snippets. e_sn() is used to escape the characters which are special inside a snippet.

The completed command is repeated below (with an extended transformation to handle lower-casing the anchor name):

#!/usr/bin/env php 
<?php
$document = file_get_contents('php://stdin'); 
$lines    = explode("\n", $document); 
$filename = $_ENV['TM_FILENAME']   

foreach ($lines as $index => $line) { 
    $tabstop = $index + 1; 
    echo '<a href="$filename#${' . $tabstop . '/(?:(\W+)|(.))/(?1:-:\L$2)/g}">' .
       '${' . $tabstop . ':' . e_sn($line) . '}</a>' . "\n"; 
}   

// escape text for use in a TextMate snippet 
function e_sn($str) { 
   return preg_replace('/[$`\\\\]/', '\\', $str); 
}
?>

The Ruby bundle is a large collection of automations that will help you write and run Ruby code. If you are a Rails user, switch the language menu at the bottom of each editor window to "Ruby on Rails" to gain access to these automations plus those defined in the Rails bundle.

Writing Ruby Code

The Ruby bundle includes a large collection of snippet that simplify day to day coding in the language. At first glance through the menus, this may seem like an overwhelming amount of information to try and become familiar with. The truth is though that there are patterns to the snippets so that you can access what you need without having to memorize a bunch of triggers. The main things you need to know are:

• Snippet triggers for Ruby's flow control keywords are just the full name of the first keyword used: if⇥, case⇥, while⇥, etc.
• Other snippet triggers are usually the first three letters of the first word in the code you want, plus the first letter of any additional words. That means you can use cla⇥ to bring up a menu of Class definition snippets, sor⇥ to get the sort() iterator, or sorb⇥ for sort_by().
• There are exception to the rule, mainly when the shortcuts can be made to read better. For example, the triggers for attr_reader(), attr_writer(), and attr_accessor() are r⇥, w⇥, and rw⇥ respectively. You also get the each() iterator with the common abbreviation ea⇥, which means you would use eal⇥ for each_line() or eawi⇥ for each_with_index().
• Some snippets are based on fictional method names like map_with_index(), deep_copy(), or application_code(). These functional names tend to be easier to recall than the actual idioms they represent.

If this is the first time you are hearing of these mnemonics, practice a bit with my examples above to become familiar with them and then take a fresh look through the Ruby bundle menu. I suspect you will be surprised by how much you can retain without stressing your memory.

Don't be too surprised if some of the triggers are smarter than you expect. Some of them will add requires to your document (unless they are already present) to make sure needed libraries are available. If you want to bypass this feature for any reason, just tack an extra - onto the end of the trigger.

The bundle also contains several commands that can be useful in writing Ruby code. Here are two examples I use every day:

• All of the iterator snippets insert a block using the braces syntax, but you can quickly get to the do/end variation by tabbing into the body of the block and triggering the "Toggle 'do … end' / '{ … }'" command (it's on ⌃{ by default).
• Rails fans will appreciate the "Insert ERb's <% .. %> or <%= .. %>" command (on ⌃> by default). You actually use this tool in HTML files even though it's defined in the Ruby bundle, since that's by far the most common usage of ERb. Trigger it once to insert the tags or repeat the keystroke to cycle through the variations.

Finally, if you are addicted to Ruby, you may just enjoy the possibility to use a little of it when writing any TextMate document. The "Execute Line / Selection as Ruby" command (on ⌃⇧E by default) will hand-off any content you can select to the Ruby interpreter and replace the selection with the results of evaluating that Ruby expression. Aside from the neat possibilities of being able to generate code, or any other content for that matter, with code, this makes for a darn handy calculator at times.

Running Ruby Code

As soon as you have some Ruby code, you are going to want TextMate to run it for you. The Ruby bundle offers several ways to do that:

• The "Run" command (on ⌘R by default) will run the code currently in the editor window in the RubyMate environment. This command has a lot of advantages over going to the command-line: output is shown in an HTML window with the standard TextMate styling; exceptions are captured by TextMate and formatted to stand out; Test::Unit files are recognized and receive a modified path that helps them locate other files; test failures and errors are hyperlinked back to the code in TextMate; and STDIN is modified to prompt with a GUI dialog when a line of input is required.
• While you can handle full test files with the above, the "Run Focused Unit Test" command (on ⇧⌘R by default) will run just the test method your caret is currently inside of. This can be quite a time saver for spot-checking changes.
• Another tool definitely worth knowing is the "Execute and Update '# =>' Markers" command (on ⌃⇧⌘E by default). To use it, add some comment markers (there is a snippet on #⇥ that will insert these for you) to the end of lines you would like to see the results of and then trigger the command. TextMate will run your code and report the result of the marked line inline in the comments. This feature is great for code posted online since it shows the source and the results together.

There's more inside the Ruby bundle, but I've tried to hit the highlights that any Rubyist can probably benefit from knowing. You can get a lot of mileage out of knowing just this much.

Thanks a lot to James for writing this post, I hope you learned something. If you’ve still got a craving for more TextMate learning, James is also the author of TextMate: Power Editing for the Mac, which explains all about the robot ninjas hidden under TextMate’s shell and how to bend them to your will.

Inserting Tags

Most of your time using the HTML bundle will of course be spent writing HTML, so learning just a few commands to make the process easier can save you a lot of time. In fact, you really only need to remember one – the “Insert Open/Close Tag (With Current Word)” command (bound to ⌃< – remember you must press the keys required to generate the characters, so likely you will use ⌃⇧,).

This command can be used to insert HTML tag pairs in a few ways:

• Press ⌃< on its own to get an empty paragraph tag; the “p” will remain selected so you can type whatever tag name you need and it will be mirrored in the closing tag – you can also add attributes to the tag without them being mirrored. Once you’re done, hit tab to move the caret between the tags and enter the content, then hit tab again to move after the closing tag.
• Type a tag name and then press ⌃< right after it to turn the word into a tag pair, with the caret between them.
• It’s also possible to invoke with a selection to convert it to a tag (including any attributes you have selected) but this is of limited use – if you want to enter attributes you should use the first form.

Using this command will not only save you time, but also ensure your tags are balanced as it inserts both tags together. If you have some unbalanced tags you can use the “Insert Close Tag” command (⌥⌘.) to close the first tag above the caret which has not been finished.

Two other useful commands are for when you have existing content which you wish to wrap in a tag – you can select some text and then use “Wrap Selection in Open/Close Tag” (⌃⇧W) to enclose the text in a paragraph tag, which you can then alter by typing over it and tabbing out as in the first command.

If you have a few lines of text which you want to wrap in tags, for example some paragraphs or list items, you can select each line and run “Wrap Each Selected Line in Open/Close Tag” (⌃⇧⌘W).

There are also snippets to insert tags or groups of tags; a few useful examples are doctype⇥, style⇥, script⇥, ⌃↩ (a break tag) and ⌥␣ (a non-breaking space). Take a look in the Insert Tag submenu of the HTML bundle for a full list.

One final useful command is “Wrap Word / Selection as Link” (⌃⇧L), which encloses the word or selection in an <a> tag, using the contents of the clipboard as the URL, and the page’s title if the URL begins with http:// (Note: this command is actually part of the Hyperlink Helper bundle, as it is designed to be used in multiple scopes).

Writing Valid HTML

There are also other commands to help you while writing HTML, such as:

• Validate Syntax (⌃⇧V) – this sends the document to the W3C’s validation service and displays the results in a HTML window, adding links to jump back to errors
• Tidy (⌃⇧H) – this command invokes the tidy tool on the document to format it and provide feedback on warnings/errors
• Documentation for Tag (⌃H) – use this on a tag to view the W3C’s reference page on the subject
• Various entity/escaping-related commands (⌘&) – the bundle includes commands to encode and decode characters, URL escape text, and insert character entities from a list

Also, for people writing XHTML you should use the TextMate preferences to set a variable called TM_XHTML with the value ‘ /’, to make all the commands and snippets insert XHTML-compliant tags.

As with all the bundles, there is really more functionality than I can cover here, so be sure to check out the bundle menu to get a good overview of the bundle’s features.

Downloads:

Blurminal – Original Post

Terminal Tab Switching – Original Post

TerminalColours – Original Post