Bookmarklet Loader is a template bookmarklet that injects your app’s .js and .css into the current page when clicked. You can grab the code on GitHub:

Bookmarklet Loader

Bookmarklet Loader is written in CoffeeScript, however bookmarklets must be JavaScript and URL encoded. CoffeeMarklet does a great job of converting CoffeeScript to bookmarklet-friendly JavaScript. I recommend you use it to generate your bookmarklet once you’ve configured Bookmarklet Loader.

Happy Holidays!

Permalink | Leave a comment  »

I’ve slowly been learning how to test my Rails projects with Rspec and I thought it would be helpful to document this experience. I’m sure there are better, faster, smarter ways to test these concepts, so please do tell me in a comment so I (and others) can learn!

To get started, make sure you have Rspec installed properly. Ryan Bates created a great Railscast that walks through setting up Rspec.

I’m going to add to this post as I create tests over the coming weeks/months. Please be patient, and don’t forget to comment if you see something that could be done better, faster, smarter!

Understanding Rspec Organization

One of my favorite features of Rspec is that it helps you easily organize your tests. Here is an example of how a simple set of tests might be organized:

describe SourcesController do
  describe "#index" do
    before :each do
      @request.env['HTTP_AUTHORIZATION'] = "Basic #{ActiveSupport::Base64::encode64('user:secret')}"
    end

    it "should have this action" do
      get :index
      response.should be_success
    end

    it "should require auth to access" do
      @request.env['HTTP_AUTHORIZATION'] = nil
      get :index
      response.status.should == 401
    end
  end
end

Rspec gives us the keyword “describe” so we can group related tests. In the above example, I’m testing the index action of the SourcesController. If I wanted to add a new action, I might create a new “describe” block called “#new”. There are no formal organization rules here (as far as I can tell), this is just my NooB convention. Post a comment if you have a best practice that I should be using!

Rspec Expectations and Matchers

In Rspec, there are a couple of concepts that will get you 80% of the way to where you need to be, then there are about a hundred concepts that get you the final 20%. To get 80%, you should start with:

object.should
object.should_not

Rspec’s Spec::Expectations module adds the “#should” and “#should_not” methods to Ruby’s Object class. These methods are the key to how Rspec works. Every object in your tests will now have these two expectation methods, which you can use to verify a value.

With #should and #should_not in our arsenal, we can go a step further and start to think about matchers. The following is a list of positive matchers. Most also have a negative equivalent (i.e. “not_equal”, “not_be_close”, etc.). You can use these matchers to make Rspec code read like a novel, which is one of the things I LOVE about Rspec.

object.should equal [value]
object.should be_close [value], [tolerance]
object.should be [value]
object.should be_between([value-x], [value-y])
object.should predicate [optional args]
object.should match [regex]
object.should be_an_instance_of [class]
object.should be_a_kind_of [class]
object.should respond_to [symbol|string]
object.should include [object]
object.should have([number]).things
object.should have_at_most([number]).things
object.should have([number]).errors_on([symbol])

To test for exceptions and changes:

lambda {[do something]}.should raise_error
lambda {[do something]}.should raise_error([exception] [, optional message])
lambda {[do something]}.should change([instance], [method]).from([x]).to([y])
expect {[do something]}.to change([instance], [method_as_symbol]).from([x]).to([y])

Testing Models

All of the tests for your models reside in the “spec/models” folder, which the Rails generator creates when you create a new model. In here, you should see a file named “[yourmodel]_spec.rb” for each model you’ve created with a Rails generator since installing Rspec.

A good rule of thumb for testing models is that you should have at least one test for every property of your model. You should also test things like validations, accessibility, and filters. But, you should only test your code (i.e. don’t test ActiveRecord, it’s already well tested).

To be continued…

Permalink | Leave a comment  »

I decided to write a super lightweight endless scroll (a.k.a. endless page, pageless, without pagination, etc.) plugin for jQuery. It will let me trigger some code whenever the user scrolls within a certain number of pixels from the bottom of the page.

I’ll get right to the juicy details. Here is the plugin code, and yes, it’s written in CoffeeScript. If you need javascript, feel free to copy and paste this code into the CoffeeScript parser at http://jashkenas.github.com/coffee-script/.

(($) ->
  $.fn.nearBottom = (options) ->
    defaults = {
      pixelsFromBottom: 100,
      delay: 250,
      callback: -> false
    }
    options = $.extend defaults, options

    do checkScrollPosition = ->
      documentHeight = $(document).height()
      scrollHeight = $(document).scrollTop()
      windowHeight = $(window).height()
      pixelsToBottom = documentHeight - scrollHeight - windowHeight

      scrollable = ->
        documentHeight > windowHeight

      nearBottom = ->
        pixelsToBottom <= options.pixelsFromBottom

      enqueueNextCheck = (delay) ->
        setTimeout checkScrollPosition, delay

      if scrollable() && nearBottom()
        if options.callback() == true
          enqueueNextCheck(options.delay)
      else
        enqueueNextCheck(options.delay)
)(jQuery)

After adding this plugin to your project, you can use it by calling nearBottom on a jQuery object.

yourFunction = ->
  alert "We're near the bottom of the page!"
  true

$(this).nearBottom {
  callback: yourFunction,
  delay: 500,
  pixelsFromBottom: 100
}

I’ve included all of the optional settings above.

• callback is the function to execute when the user scrolls close to the bottom of the page. This function must return a value of true for the plugin to continue to check the user’s scroll position. In other words, if you want to stop the plugin, return false and your callback will not be called again.
• delay is how many milliseconds to wait between each check of the scroll position

• pixelsFromBottom is the distance from the bottom of the page that triggers the callback.

  I’ll add this to GitHub soon!

Permalink | Leave a comment  »

Just about every time I start a new Rails project, I find myself building out a way to reference records based on a masked identifier. It just feels wrong to me to display the count of the number of records in the database, which is the Rails default.

UPDATE: I created a Rails plugin that makes it easy to add a non-incrementing masked identifier to any ActiveRecord object. Check out the Github page for more info:

http://github.com/matthodan/masked-identifier

To solve this problem, I built a couple libraries that a) generate a guaranteed-to-be-unique code to use for a masked identifier and b) automatically add the masked identifier code to new records when they are saved for the first time.

Here is the code for the code generator:

# CodeGenerator creates unique codes based on a column of an ActiveRecord object
#
# Usage:
# 1) Copy this file into your [rails project]/lib directory
# /lib/code_generator.rb
#
# 2) Add an initializer to your Rails project
# require 'code_generator'
#
# 3) Generate a unique code based on an ActiveRecord model
# CodeGenerator.unique_code(YourModel, 'name_of_unique_column', length_of_code)

class CodeGenerator
  def self.unique_code(klass, field, size)
    code = self.random_code(size)
    until self.code_is_unique?(klass, field, code)
      code = self.random_code(size)
    end
    return code
  end

  private
  def self.code_is_unique?(klass, field, code)
    return true if klass.class.send('find_by_' + field, code).nil?
  end

  def self.random_code(size)
    charset = %w{ 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H J K L M N O P Q R T U V W X Y Z }
    (0...size).map { charset.to_a[rand(charset.size)] }.join
  end
end

Here is the code to automatically add a masked identifier:

# Include this module in an ActiveRecord object with a column named 'masked_identifier' to
# automatically generate a masked identifier when a new record is saved that can then be used
# to lookup records without revealing how many records have been created
#
# Usage:
# 1) Copy this file into your [rails project]/lib directory
# /lib/has_masked_identifier.rb
#
# 2) Add an initializer to your Rails project
# require 'has_masked_identifier'
#
# 3) Add 'has_masked_identifier' to your ActiveRecord model
# class YourModel < ActiveRecord::Base
#   has_masked_identifier
# end
#
# Optionally, you can include a hash as a parameter to has_masked_identifier that includes a
# custom named column and/or length to override the default 'masked_identifier' column name 
# and/or default length of 8 characters:
# class YourModel < ActiveRecord::Base
#   has_masked_identifier column: 'some_other_column', length: 15
# end

module HasMaskedIdentifier
  def self.included(base)
    base.send :extend, ClassMethods
  end

  module ClassMethods
    attr_accessor :masked_identifier_column, :masked_identifier_length

    def has_masked_identifier(options = {})
      send :include, InstanceMethods
      self.masked_identifier_column = options[:column] || 'masked_identifier'
      self.masked_identifier_length = options[:length] || 8
      before_save :add_masked_identifier, on: :create
    end
  end

  module InstanceMethods
    private

    def add_masked_identifier
      column = self.class.masked_identifier_column
      length = self.class.masked_identifier_length
      raise ArgumentError, 'Column does not exist' unless self.respond_to?(column)
      self[column.to_sym] = CodeGenerator.unique_code(self, column, length)
    end
  end
end

ActiveRecord::Base.send(:include, HasMaskedIdentifier)

Sorry for the lower-than-average quality explanation in this post (I only had about 30 min to pull it together). I’ll come back and improve on it when I turn this into a Rails plugin. That said, I wanted to get this post out there so others could see.

Permalink | Leave a comment  »

Note: I was not paid by Plugable to write this post-- I genuinely love their product.

Have you ever wanted to run dual-displays with your MacBook Pro?  With the Plugable USB 2.0 UGA Multi-Display Adapter, it's easy and affordable ($64.50 on Amazon at the time of this writing).  But before we get into details, here is the finished product

Yes, I know-- I have three displays hooked up.  Why three?  Why not.  You only need one Plugable adapter (and a Mini DisplayPort adapter) to run two displays, but I thought it would be cool to abandon the Mini DisplayPort and run two Plugable adapters through my USB hub.

As it turns out, abandoning the Mini DisplayPort probably isn't the best option.  The Plugable adapter uses your computer's CPU instead of the graphics chip, so you'll lose CPU cycles if your display is rapidly refreshing a large area (e.g. playing video).  This is by far the most underwhelming thing I noticed-- on my circa 2010 MacBook Pro, there is noticable choppiness when watching fullscreen video at 1920x1080 resolution.  That said if you're not playing video, you probably won't be able to tell the difference between your Mini DisplayPort display and your Plugable display.

My recommendation: Buy one Plugable adapter and keep your second display hooked to the Mini DisplayPort.

Unpacking

Here are some pictures I took while unpacking one of my Plugable adapters:

As you can see, Plugable includes a bunch of adapters with the standard USB-to-DVI adapter.  With these adapters you can also use the adapter for USB-to-VGA and USB-to-HDMI.

Here is what the adapter looks when hooked up:

As you can see, the adapter is fairly compact and has a green light that illuminates.  It draws all of its power from the USB line, so no additional power cable necessary.  Sweet!

Installation

Installation was super easy.  You just install a driver and plug in the adapter.  My MacBook Pro automatically recognized the additional display.  The only potential gotcha I noticed is that you download the driver from DisplayLink, not Plugable.  This is because Plugable's adapter wraps DisplayLink's DL-195 chip.  You can download the Mac drivers here:

http://www.displaylink.com/support/mac_downloads.php

I'm using the 1.6 beta 4 version of the drivers and everything is working smoothly.

That's all for now.  You can read more about the Plugable adapter on Plugable's website.  I'll post an update after I've spent some more time using my dual display setup.

Permalink | Leave a comment  »

1

<%= error_messages_for :user %>

1
2
3
4

<%= form_for @user do |f| %>
  <%= f.text_field :name %>
  <%= f.error_message_on :name %>
<% end %>

1
2
3
4
5
6
7
8
9
10

class User < ActiveRecord:Base
  validate :user_is_happy_and_broke

private
  def user_is_happy_and_broke
    if self.state_of_mind != 'happy' || self.fiscal_status != 'broke'
      errors.add :user_not_happy_and_broke, 'User must be happy and broke to continue'
    end
  end
end

1
2
3

<%= form_for @user do |f| %>
  <%= f.error_message_on :user_not_happy_and_broke %>
<% end %>

Permalink | Leave a comment  »

Want to reduce the size of your Heroku slug? Easy-- move your static assets to S3.  Great, problem solved, but wait... What do you do with the static assets left in your repository? 

I found myself asking this question today...

My first though was to use .gitignore, which would exclude the static assets from my git repository and in turn my Heroku slug.  However, this approach would leave me without version control of my static assets.  Not ideal...

Then I did a little research and came up with this better approach: .slugignore.  Just like .gitignore, .slugignore sits in your project folder and identifies files to ignore.  However, instead of excluding specified files from your git repository, it excludes them only from your slug.  Genius!

Heroku has a great explanation of .slugignore in their docs. These are some examples of files that Heroku notes you may wish to include in your .slugignore:

• Unit tests or specs
• Art sources (like .psd files)
• Design documents (like .pdf files)
• Test data (for example, the feedtools gem has 11 megs of XML sample files for its unit tests)

Thanks to Terence Lee and Matthew Todd for helping me discover .slugignore.

Permalink | Leave a comment  »

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#!/usr/bin/env ruby

class Parent
  private
  def name
    'Mommy'
  end
end

class Child < Parent
  def get_parent_name
    puts name                                           # Implicit receiver
    puts self.name rescue puts 'NoMethodError'          # Explicit receiver
    puts Parent.new.name rescue puts 'NoMethodError'    # Explicit receiver
  end
end

Child.new.get_parent_name
# => Mommy
# => NoMethodError
# => NoMethodError

Permalink | Leave a comment  »

Permalink | Leave a comment  »

While working on an address form for a rails project, I came across this nasty little task of building an array of country, state, and province codes.  I ended up downloading PayPal's official list of country, state, and province codes from their API documentation and making the following:

Country codes:

U.S. state codes:

Canadian province codes:

Other state/province codes:

Hopefully this saves you the time you would have spent converting PayPal's lists of codes into ruby arrays.

Enjoy!

Permalink | Leave a comment  »

mkdir ssl-cert

cd ssl-cert

openssl genrsa -des3 -out host.key 2048

openssl req -new -key host.key -out host.csr

Country Name (2 letter code) [AU]:US

State or Province Name (full name) [Some-State]:California

Locality Name (eg, city) []:San Francisco

Organization Name (eg, company) [Internet Widgits Pty Ltd]:Your Company Name

Organizational Unit Name (eg, section) []:secure.yourdomain.com

Common Name (eg, YOUR name) []:secure.yourdomain.com

Email Address []:contact@yourdomain.com

Please enter the following ‘extra’ attributes

to be sent with your certificate request

A challenge password []:

An optional company name []:

Where is your certificate going to be hosted? Third Party

Enter your Certificate Signing Request (CSR) below: [copy contents of 'host.csr' here]

Select your certificate issuing organization: GoDaddy

Is this certificate for Intel vPro? No

cat secure.yourdomain.com.crt host.key > host.pem

openssl rsa -in host.pem -out nopassphrase.pem

openssl x509 -in host.pem >>nopassphrase.pem

-----BEGIN RSA PRIVATE KEY-----

...

-----END RSA PRIVATE KEY-----

cat nopassphrase.pem gd_bundle.crt > public.pem

openssl rsa -in host.key -out private.key

heroku ssl:add ../ssl-cert/public.pem ../ssl-cert/private.key

heroku addons:add custom_domains:basic

heroku domains:add secure.yourdomain.com

heroku addons:add ssl:hostname

Permalink | Leave a comment  »