If you are using emacs, you can use the :emacs_with_trace open command, and get the stack trace as a navigable compilation buffer (next to || below) the source file in a split frame. For this to work, you’ll need to add the following function to your emacs init:

See github for the code and README.

You can add filters that allow you to ignore some exceptions, and filters that allow you to scope the backtrace search. The backtrace scoping is useful for opening the last call in your application code when the exception occurs in a framework or lib.

If you are on MacOSX and have the growl gem installed, you will get a growl notification with the exception message when the file is opened.

Editors

Out if the box, the gem supports three editors (with the following open commands):

    :emacs => '/usr/bin/emacsclient -n +{line} {file}',
    :textmate => '/usr/local/bin/mate -a -d -l {line} {file}',
    :macvim => '/usr/local/bin/mvim +{line} {file}'

Note: if using emacs, you will need to be running emacsserver. To start the server: M-x server-start
or add (server-start) to your init.

Configuration

To configure, pass a block to the configure method:

    OpenException.configure do |oe|
      # open_with can be one of the built in editors (:emacs, :macvim, :textmate)
      # or a command to execute to open the file, where {file} and {line} will be replaced
      # with the file path and line number, respectively. See 'Editors' above for an example.
      # The default editor is :emacs.
 
      oe.open_with = :emacs
 
      # you can add exclusion filters to ignore exceptions. A filter can be an exception class to 
      # ignore, or a proc that is passed the exception, and should evaluate to true if the exception 
      # should be ignored. Be careful with using a class - it uses is_a?, so any subclasses of the
      # passed class will be ignored as well. The list of filters is [] by default.
 
      oe.exclusion_filters << SomeErrorClass
      oe.exclusion_filters << lambda { |exception| true if exception_should_be_excluded }
 
      # you can scope the search for the file:line to open with a filter as well. A filter can be a 
      # regular expression that is matched against the line, or a proc that is passed the line and 
      # should evaluate to true if the line should be used. The first line that any filter passes for 
      # will be the file:line that is opened. This is useful for opening the point in the stack just
      # before control passes out of your app code when the exception occurs in an external 
      # lib/framework. The list of filters is [] by default. 
 
      oe.backtrace_line_filters << %r{/app/root/(app|lib)} 
      oe.backtrace_line_filters << lambda { |backtrace_line| true if line_should_be_used }
 
    end

Rails Integration

The gem also alias chains in to rails’ ActionController#rescue_action_locally method to automatically open exceptions in development mode. The gem also adds the following filter to the :backtrace_line_filters to scope the opened files to the app:

    @%r{#{Rails.root}/(app|lib)}@

To replace or remove this filter, you will need to reset the :backtrace_line_filters in your configure block:

    OpenException.configure do |oe|
      oe.backtrace_line_filters = []
      oe.backtrace_line_filters << my_new_filter
    end

This has been tested with rails v2.3.5, but should work fine with 2.1 <= rails < 3. It may work with rails 3 as well, I just haven’t yet looked at rails 3.

Standalone/Other Frameworks

    # To manually open an exception, or wire it up in another framework, you call:
    OpenException.open(exception)
 
    # You can override the default (or configured) options by passing a hash as the second arg:
    OpenException.open(exception, {:open_with => :textmate, :backtrace_line_filters => [filter, another_filter])

The source is on github, and the gem is on rubygems.

So here it is. Its a package that allows you to comment out a block of ruby code from a keybinding (I’m sure there is code out there to do this already, but it was a fun learning challenge).

The main function is comment-ruby, which I have bound to C-:. If there is a region active, it comments out the region. If that region is less than five lines, each line is commented with ‘# ‘, otherwise the entire region is wrapped in =begin...=end. If the region is not active, the current line is commented out with ‘# ‘.

After a region has been commented out, the point (cursor) is set to the line above or below the region, depending on whether the point was at the beginning or end of the region when called.

Here is the code – it probably isn’t idiomatic lisp. If you have any suggestions on improving the code or making it more idiomatic, please let me know!

Like most programmers, I type a lot – many hours a day, most days of the week. The keyboard is the primary conduit of my creative expression most of the time, whether I’m writing code or constructing elaborate stories to impress friends, clients, or co-workers (aka email/chat/this blog). For the last couple of years, I’ve been mildly obsessed with making that conduit more efficient. I’ve tried several different keyboards and entirely new keyboard layouts.

I stopped the keyboard search with the Kinesis Advantage – it works really well for me, and is the easiest keyboard for touch typing that I’ve ever used. But the keyboard layout search continued. The productivity hit during the learning period for Dvorak or Colemak was too great, and I quickly slid back to Qwerty.

I could type as fast as I wanted in Qwerty, so I tried to figure out what was really bugging me about my typing. I realized it was the shift key – I was frustrated with the high percentage of characters I typed that involved shift. I primarily code in Ruby, which uses ‘_’ much more often than ‘-’ (about 14 times more often), ‘:’ more than ‘;’ (about 78 times more often!), and ‘{}’ more than ‘[]‘ (or so I thought – more on that later).

I then decided to create a custom keyboard layout that would reduce the need for the shift key when coding. My goals were:

• no remapping of the letter keys, since my muscle memory knows where they all are
• remap commonly used symbols to be available without the shift key
• be easy to learn, so no remapping characters to new keys

Using the Ukelele keyboard layout editing tool (for MacOS), I played around with some layout ideas before settling on the one I’ve been using since May 2009.

The Layout

Since I mostly code in Ruby, and mostly use symbols in code vs. email/chat/etc., I remapped the shifted symbols I used more often.
I ‘shift-swapped’ (meaning the symbol you get with or without the shift key depressed are reversed) the following character pairs:

• { [
• } ]
• | \
• ~ `
• : ;
• _ -

I assumed that I used most of the symbols on the top row number keys more than I used the numbers, so I shift-swapped the 1 – 0 number keys with the corresponding symbol. If caps-lock is on, number keys revert to normal, but all of the other symbol keys remain swapped (meaning when caps-lock is on, pressing the ’1′ key will give you a 1, but pressing the ‘[' key will give you a {). Since the Kinesis keyboard does not have a separate keypad, this makes entering number sequences easier.

The caps-lock key has been moved to the f1 key, and I use the original caps-lock as a control key (for Emacs). This mapping can't be done by Ukelele, since it cannot remap function or modifier keys, so I did this using the remapping functionality in the Kinesis keyboard itself.

Analysis

After six weeks or so of using the new layout, I decided to analyze a large ruby codebase to see what my shift pair ratios actually were (something I should have done before creating a new layout). Using this script, I got the following results:

Analyzed 457 files, 25060 lines
` ~     25     58  2.320
1 !   1161    713  0.614
2 @    564   2700  4.787
3 #    416   1914  4.601
4 $    264     55  0.208
5 %    359    303  0.844
6 ^    257     44  0.171
7 &    152    226  1.487
8 *    176    115  0.653
9 (    196   4479  22.852
0 )   1761   4485  2.547
- _   1559  21837  14.007
[ {   1385   1304  0.942
] }   1396   1306  0.936
\ |    144   1480  10.278
; :    108   8446  78.204
= +   5588    729  0.130
‘ "   5585   3909  0.700
, <   4737    791  0.167
. >  10257   2067  0.202
/ ?   1077   1054  0.979

Columns one and two are the shift pairs. Columns three and four are the occurrence counts for each character in the pair. The last column shows the ratio of the second character (normally shifted) to the first character (normally not shifted). So a higher number in that column indicates an advantage to swapping the shift pair.

I looked at the shift pairs I had swapped, along with the other symbol shift pairs that I did not swap (the last five lines above). There are some big wins here with my current remapping, along with some loses. The '[]'/'{}' swap was a small mistake - looks like I access elements of collections slightly more often than I define inline blocks or explicit hashes (which is kind of obvious in hindsight. In fact, on reflection I would think that collection access would happen considerably more often than inline block creation). And some of the number key remaps are big loses based on the ratios, but the lowest ratio pairs there have generally low volume. After this analysis, I didn't undo any of the remappings, though I should have reversed (and still should reverse) the bracket/brace swap.

Usage

The name of this layout is 'rubyist'. If you are interested in giving it a try, download the MacOS keylayout file here, and put it in ~/Library/Keyboard Layouts/.

I don't expect this layout to work well for everyone, or really anyone other than me. I do think all of us could benefit from evaluating the text we type the most, and seeing if some keyboard layout tweaks could make us more efficient. If you do want to give your own layout a try, check out these platform specific tools:

• MacOS: Ukelele
• Linux: XKB
• Windows: Microsoft Keyboard Layout Creator

For the last few months, I’ve been playing with the pomodoro technique to manage my time and stay focused on the task at hand. It works best for me when I’m stressed and have an overwhelming workload. It helps me focus on the immediate task, and not get distracted too much by all of the other stuff I need to do.

One issue with managing the technique is keeping interruptions to a minimum. When I start a pomodoro, I’ll quit email, twitter, and chat. But we are a distributed team, and I work from home 95% of the time. I want to let the rest of the team know I’m around, but also let them know that I’m in a pomodoro, and to only interrupt in emergencies. Since we primarily use Campfire to communicate, I set up a ‘Status’ room there that allows us to post what we are up to/where we are at/etc. Its not only useful for pomodoro updates, but also ‘off to lunch’, ‘gone for the day’, etc. (And here is a third sentence that ends in etc.) But manually entering those status updates means they won’t happen. So I wrote a simple update script using the lovely tinder gem. It consists of two files – the script itself:

and the config file (~/.campfire_status):

But pomodoro status updates still require a manual step to run the script. Enter Pomodoro, a MacOS pomodoro client by Ugo Landini. His client allows integration with growl, twitter, and applescript. So I added the following applescript snippets to update the status for me:

A couple of gotchas I ran in to:
* the Pomodoro app does not allow copy & paste in the applescript text areas, making it a bit of a pain to enter
* the Pomodoro app also has a file selector next to each applescript text area, but I could not get it to recognize the saved applescripts
* the Campfire API seems to ignore requests from users that are currently logged in(?), so the status updates come from another account (in our case, we have a ‘service-bot’ account that posts messages from other services). That’s why there is a USER_NAME setting that is displayed with the message.

This plugin adds the following functionality to the Rails module to help with determining the current enviroment:

  >> Rails.environment       # a convenience alias to Rails.env
  => "development"
  >> Rails.development?
  => true
  >> Rails.not_development?
  => false
  >> Rails.production?
  => false
  >> Rails.not_production?
  => true
  >> Rails.test?
  => false
  >> Rails.not_test?
  => true

Not only does it provide env? and not_env? methods for the standard environments, it also provides those methods for any environment you define in config/environments/ (in fact that is how it learns about all of the environments, including the standard three). So if you define new environments in config/environments/ they will be picked up automatically.

Install with: script/plugin install git://github.com/tobias/rails_habitat.git

It lives on github.

Edit: see David’s comment below for the built in way to do this (in Rails >= 2.2).

Installation and Setup

Install:

gem install tobias-zendesk_remote_auth

Setup:

You will need to give the gem your token and authentication url, perhaps in an initializer:

  Zendesk::RemoteAuth.token = 'YOUR-TOKEN'
  Zendesk::RemoteAuth.auth_url = 'https://yourcompany.zendesk.com/access/remote/'

and config the gem in environment.rb (if using rails):

config.gem 'tobias-zendesk_remote_auth', :lib => 'zendesk_remote_auth', :source => http://gems.github.com'

Usage

Mixin the Zendesk::RemoteAuthHelper module wherever needed, then call:

  zendesk_remote_auth_url(:name => 'user name',
                          :email => 'user email',
                          <optional params>)

This will return a url you can redirect the user to to log them in to your zendesk account.

As a convenience, you can pass a user object to zendesk_remote_auth_url:

  zendesk_remote_auth_url(user)

This user must respond_to? :name and :email, and its :id will be used as the :external_id (making it useless with user objects that return an ephemeral object_id, but works well with ActiveRecord and the like). If the user object responds to :zendesk_organization, that will be used as the rganization for the call.

This method will generate and include the hash of the parameters for you if necessary.

Example Auth Controller

Here is an example controller that handles login and logout for zendesk:

  # Uses restful-authentication style auth. 
  # 
  # Define the following in routes.rb:
  # map.with_options :controller => 'zendesk_auth' do |zd|
  #   zd.connect '/zendesk/authorize', :action => 'authorize'
  #   zd.connect '/zendesk/logout', :action => 'logout'
  # end
  class ZendeskAuthController < ApplicationController
    include Zendesk::RemoteAuthHelper
 
    skip_before_filter :login_required, :only => :logout
 
    def authorize
      redirect_to zendesk_remote_auth_url(current_user)
    end
 
    def logout
      redirect_to logout_url
    end
 
    protected
    def login_required
      if !logged_in?
        flash[:notice] = 'You must log in to access the support site.'
        store_location
        redirect_to login_path
      end
    end
  end

  # clean up app/models a bit
  %w{mailers observers sweepers}.each do |dir|
    config.load_paths << "#{RAILS_ROOT}/app/#{dir}"
  end

As a bonus, you can now automatically record your observers with ActiveRecord instead of having to add them individually in environment.rb:

  config.active_record.observers = Dir.glob("#{RAILS_ROOT}/app/observers/*.rb").collect do |filename|
    filename.split('/').last.split('.').first.to_sym
  end

• remote shell – same as ssh’ing to the server (this is the default command, so it can be called with just remote)
• remote console – executes a script/console on the server
• remote logtail – executes tail -f log/<environment>.log on the server
• remote cmd <some command> executes command on the server, displaying the result. It cd‘s to the remote app root first.
• remote scp <local_file> :<remote_file> provides scp. Prefix remote files with ‘:’

Here is the output of remote usage:

Executes commands on a remote server over ssh. Configuration is in:
/Users/tobias/customers/DealerIgnition/dealer_ignition/script/../config/server_remote.yml
 
You can override the profile used with -p profile. The default profile is: app
 
Learn more in the readme:
/opt/local/lib/ruby/gems/1.8/gems/tobias-server_remote-0.2.0/lib/server_remote/../../README.textile
 
remote commands are:
 
    DEFAULT COMMAND   shell
 
    cmd               executes an arbitrary command on the server after a cd to the app path
    commands          List all 'remote' commands
    console           executes remote console
    help              Provide help documentation for a command
    logtail           executes remote tail -f on the log
    scp               copies files over scp (prefix remote files with ':')
    shell             executes remote shell
    usage             prints usage message
 
For help on a particular command, use 'remote help COMMAND'.

It uses remi’s simplecli gem.

I plan to add other commands as needed, or you can open up Remote::Commands and add your own.

Installation

You will need to install the gem (only once), then setup any apps where you want to use it.

  sudo gem install tobias-server_remote --source http://gems.github.com/
  server_remotify path_to_app

Usage:

  CreditCardValidator::Validator.valid?('1111 2222 3333 4444')
 
  # allow test numbers to be valid (for development) 
  CreditCardValidator::Validator.options[:test_numbers_are_valid] = true
  CreditCardValidator::Validator.valid?('1111 2222 3333 4444')
 
  # limit the card types you allow
  CreditCardValidator::Validator.options[:allowed_card_types] = [:visa, :mastercard]
  CreditCardValidator::Validator.valid?('1111 2222 3333 4444')

Supported card types:

  :amex, :discover, :diners_club, :master_card, :visa

Whitespace is stripped from the number automatically.

The following things are tested:

1. does the luhn validation code add up? (see http://en.wikipedia.org/wiki/Luhn_algorithm)
2. does the number range and length seem right? (see http://en.wikipedia.org/wiki/Bank_card_number)
3. is it one of several well-known test numbers?

Note: this only validates that the number is of a valid format, it does not check if it is an actual credit card number. You will need to talk to your payment gateway to learn that.

You can also use the validator to learn about the type of the card:

  # gives the type back as a string (visa, master_card, etc)
  CreditCardValidator::Validator.card_type(number)
 
  CreditCardValidator::Validator.is_visa?(number)
  CreditCardValidator::Validator.is_master_card?(number)
  # etc. - works for all of the supported card types
 
  CreditCardValidator::Validator.is_allowed_card_type?(number)

To Install:

  gem install tobias-credit_card_validator --source http://gems.github.com

The source is available on github