Techspeak

Drop-Dead Simple Authentication for Microapps

2010-03-03T23:24:00.007-06:00

For Inspectinator (a sinatra microapp), I needed a database-less authentication solution that was as lightweight as possible, but with a reasonable amount of security and maintainability. I came up with something that suits this purpose well, and I'm sharing it in case anyone is looking for something similar. I call it EasyAuth.

To use EasyAuth to authenticate your sinatra app, you first need to generate hashed passwords for each user you want to allow into your system. You can do this easily in IRB:

$ irb -r lib/easy_auth/easy_auth.rb
irb(main):001:0> EasyAuth.hash_password("foobar")
=> "8843d7f92416211de9ebb963ff4ce28125932878"

This should be stored in your easy_auth.rb, in the AUTHORIZED_USERS hash.

Next, you mix-in EasyAuth, and in your password-protected route you do something like:

include EasyAuth

get '/admin' do
  if_auth do
    erb :'admin/index'
  end
end

post '/admin' do
  if_auth(params[:login], params[:password]) do
    redirect '/admin'
  end
end

EasyAuth yields to the block if authentication is successful (either based on the passed-in credentials, or cookies). It defaults to rendering /admin/login if not already authenticated, so throw a username/password form on that page and you should be good to go.

Drop-Dead Simple Token Generation -- Fixnum#to_s

2010-02-14T16:30:00.001-06:00

For Inspectinator, I needed a lightweight token generator to allow people to share their results. I found a great solution, and learned a cool ruby trick, too.

The trick is in Fixnum (and Bignum), #to_s takes an optional argument: a number in (2..36). That number is the base it will print the number in (default is 10).

So, for instance (from the ruby docs), to convert a number to binary:

12345654321.to_s(2) #=> "1011011111110110111011110000110001"

For my token, I went with an 8-character, base 36 number, which gives me almost 3 trillion possible values (should be plenty). To get the 8 characters, I use rand(36**8). I don't do any checking on the length, so 8 is actually the max length (and 1 is the min). In practice, though, the vast majority of tokens will be the target length. On my system, I generated 10,000,000 tokens, and 9,722,373 were 8 characters. I chose to accept that as "close enough" because 1) it doesn't really matter to me if tokens are shorter, and 2) I think the simplicity and elegance of this solution is worth a little uncertainty.

Then, (since I'm using active record), it's just a matter of adding a before_create to set it up:

def set_token
  t = nil
  begin
    t = rand(36**8).to_s(36)
  end while InspectString.find_by_token(t)

  self.token = t
end

Announcing Inspectinator

2010-02-14T15:39:00.000-06:00

I've been wanting to experiment with sinatra for a while, so I popped something off my things-to-do-someday list and put together Inspectinator. It's aim is pretty straight-forward: parse standard ruby #inspect strings into a more palatable form. It parses a string into a system of nested objects, and displays it as a tree. Some simple jQuery let's you drill down to the level of detail you want. You can also link to your results (like pastie for inspects).

Obviously #inspect output can be overridden to anything, but as long as it's along the lines of standard ruby or rails forms, it should be parseable. If you find something that won't parse (or parses wrong), hit the link at the top ("Parse Error?") and I'll have a look.

It's still in development, and I'm definitely open to thoughts/suggestions about improvements.

Ruby Hoedown '09

2009-08-30T00:27:00.001-05:00

This weekend I was in Nashville, TN for Ruby Hoedown 2009. There were some great talks -- my favorites were Ben Mabey's Cucumber talk, Luigi Montanez's talk on using public data APIs for civic coding, and Jim Weirich's excellent (and impromtu) talk on Git's internals.

After my recent difficulties with getting Rhodes working for mobile development, I was really excited about Leon Gersing's talk about Appcelerator Titanium, but I missed all but the last five minutes of it because the schedule was changed for some reason (I was skipping what I *thought* was something else). =/ Hopefully he'll post some slides.

The resort where the event was held was horrid, but the conference was a lot of fun. Hope they continue this next year.

Erlang & Ruby -- Ring Network

2009-08-24T21:50:00.004-05:00

As part of my Erlang self-education, I'm doing a selection of sample problems (from the "Programming Erlang" book) in both Erlang and my language of choice: Ruby. The idea is to explore the differences between these very different languages.

Today's problem is to write a ring network benchmark. Given a network of N nodes, where each node is pointing to the next in line (or back to the first), each node should forward a received message along, until it has gone around the ring M times (so that a total of N * M messages are sent).

To start with, I came up with an Erlang module to spawn a set of processes, and pass along a message record. It was pretty ugly at first, but with a little refactoring it turned out alright:

-module(ring_network).
-export([start_ring/1, start_message/3]).

-record(message,
  {loops_remaining=300,
    times_sent = 0,
    runtime, wall_clock, owner, note}).

start_ring(N) ->
  spawn(fun() ->
        FirstPid = start_ring(N-1, self()),
        io:format("Starting node ~p (~p) pointing to ~p~n",
          [N, self(), FirstPid]),
        loop(N, FirstPid) end).

start_ring(N, Next) ->
  Pid = start_node(N, Next),
  if
    N > 1 -> start_ring(N-1, Pid);
    true  -> Pid
  end.

start_node(Id, Next) ->
  spawn(fun() ->
        io:format("Starting node ~p (~p) pointing to ~p~n",
          [Id, self(), Next]),
        loop(Id, Next)
    end).

start_message(Pid, Msg, N) ->
  {Runtime, _} = statistics(runtime),
  {WallClock, _} = statistics(wall_clock),
  Pid ! #message{
    loops_remaining = N,
    runtime         = Runtime,
    wall_clock      = WallClock,
    owner           = Pid,
    note            = Msg}.

loop(Id, Next) ->
  receive
    Message ->
      case Message#message.owner == self() of
        false ->
          Next ! Message#message{
            times_sent = Message#message.times_sent+1},
          loop(Id, Next);
        true ->
          case Message#message.loops_remaining == 0 of
            false ->
              Next ! Message#message{
                times_sent = Message#message.times_sent + 1,
                loops_remaining = Message#message.loops_remaining - 1},
              loop(Id, Next);
            true ->
              print_totals(Message),
              loop(Id, Next)
          end
      end
  end.

print_totals(Message) ->
  {R2, _} = statistics(runtime),
  {W2, _} = statistics(wall_clock),
  U1 = (R2 - Message#message.runtime),
  U2 = (W2 - Message#message.wall_clock),
  io:format("~n"),
  io:format("Sent '~p' ~p times in..~n",
    [Message#message.note, Message#message.times_sent]),
  io:format("  Runtime: ~p milliseconds~n", [U1]),
  io:format("  WallClock: ~p milliseconds~n", [U2]).

Next I applied the same pattern in ruby. I created a Node class, told it where the next node was, and had it forward messages along the proper number of times:

class Node
  attr_accessor :next_node, :number

  def initialize(number, next_node = nil)
    @number = number
    @next_node = next_node
  end

  def self.ring_network(node_count)
    nodes = Array.new(node_count)
    nodes[0] = Node.new(1)
    (1..node_count-1).each do |i|
      nodes[i] = Node.new(i+1, nodes[i-1])
    end
    nodes[0].next_node = nodes[-1]
    nodes[-1]
  end

  def gets_message(msg)
    if msg.owner == self.object_id
      if (msg.passes_remaining-=1) == 0
        msg.print_totals
        return
      end
    end
    msg.owner = self.object_id if msg.owner.nil?

    msg.total_passes += 1
    next_node.gets_message(msg)
  end
end

class Message
  attr_accessor :runtime, :wallclock, :note,
    :passes_remaining, :owner, :start_time, :total_passes

  def initialize(note, passes_remaining = 300)
    @total_passes = 0
    @start_time = Time.now
    @note = note
    @passes_remaining = passes_remaining
  end

  def print_totals
    puts
    puts "Sent #{total_passes} messages in..."
    puts "  WallClock: #{(Time.now - @start_time) * 1000} milliseconds"
  end
end

The first impression is just what you'd expect: Ruby is easier to read, and erlang is *much* faster:

1> Pid = ring_network:start_ring(10).
Starting node 10 (<0.59.0>) pointing to <0.68.0>
Starting node 9 (<0.60.0>) pointing to <0.59.0>
Starting node 8 (<0.61.0>) pointing to <0.60.0>
Starting node 7 (<0.62.0>) pointing to <0.61.0>
Starting node 6 (<0.63.0>) pointing to <0.62.0>
Starting node 5 (<0.64.0>) pointing to <0.63.0>
Starting node 4 (<0.65.0>) pointing to <0.64.0>
Starting node 3 (<0.66.0>) pointing to <0.65.0>
Starting node 2 (<0.67.0>) pointing to <0.66.0>
Starting node 1 (<0.68.0>) pointing to <0.67.0>
<0.59.0>

2> ring_network:start_message(Pid, hello_world, 300).
{message,300,0,270,298496,<0.59.0>,hello_world}

Sent 'hello_world' 3000 times in..
 Runtime: 0 milliseconds
 WallClock: 3 milliseconds

Versus...

irb(main):001:0> node = Node.ring_network(10); msg = Message.new('Hi!', 300); node.gets_message(msg)

Sent 3000 messages in...
WallClock: 79.336 milliseconds
=> nil

The real difference comes out when you increase the numbers:
(Erlang):

1> Pid = ring_network:start_ring(10000).
<0.33.0>

2> ring_network:start_message(Pid, hello_world, 10000).
{message,10000,0,460,40488,<0.33.0>,hello_world}

Sent 'hello_world' 100000000 times in..
 Runtime: 95350 milliseconds
 WallClock: 157455 milliseconds

(Ruby):

irb(main):002:0> node = Node.ring_network(100); msg = Message.new('Hi!', 300); node.gets_message(msg)
SystemStackError: stack level too deep
  from ./ring_network.rb:29:in 'gets_message'
  from ./ring_network.rb:29:in 'gets_message'
  from (irb):2
  from :0

In both cases, we're using recursion to wait for another message after processing one. In Erlang's case, though, it compiles tail recursion as a JUMP statement, which doesn't eat up stack space. Ruby doesn't do this, which is why I get a "stack too deep" when I up the number of loops. To get around this in ruby, I would have to move towards the Erlang module of forking off separate processes (not just separate instances), each listening for some interprocess communication.

Erlang & Ruby

2009-08-24T18:13:00.002-05:00

I've been playing around with Erlang lately, and it's been quite a departure from the language I'm most comfortable with (and use everyday): Ruby. As part of my exploration, I'm doing a variety of sample problems (from the "Programming Erlang" book, among other places) in both Ruby and Erlang, and comparing the different implementations I come up with. Erlang and Ruby are meant to solve different types of problems, and the apples-to-oranges nature of the comparison should be kept in mind. The goal is to improve both my Erlang and my Ruby.

I'll be posting on this periodically under the tag erlang_ruby.

ActiveRecord Callbacks Trigger on Clean Objects

2009-08-19T22:01:00.000-05:00

I came across this issue the other day at work, and I'm not really sure how I feel about it. It doesn't necessarily seem right or wrong, but was definitely unintuitive for me...

Since Rails 2.1, we have had dirty object checking, which prevents ActiveRecord from saving an object if if hasn't changed:

>> person = Person.first
Person Load (0.9ms) SELECT * FROM "people" LIMIT 1
=> #<Person id: 1, first_name: "Patrick", last_name: "Schless", nickname: nil, created_at: "2009-08-20 02:21:13", updated_at: "2009-08-20 02:22:32">

>> person.save
=> true

>> person.nickname = "nick"
=> "nick"

>> person.save
Person Update (20.6ms) UPDATE "people" SET "updated_at" = '2009-08-20 02:31:17', "nickname" = 'nick' WHERE "id" = 1
=> true

That part is good, but what happens when you have a callback defined?

>> Person.after_save { puts 'After save...' }
=> [#<ActiveSupport::Callbacks::Callback:0xb7147898 @identifier=nil, @method=#<Proc:0xb71479d8@(irb):6>, @kind=:after_save, @options={}>]

>> person.nickname = nil
=> nil

>> person.save
Person Update (2.4ms) UPDATE "people" SET "updated_at" = '2009-08-20 02:33:21', "nickname" = NULL WHERE "id" = 1
After save...
=> true

>> person.save
After save...
=> true

As we see there, the callback gets triggered even if the save is short-circuited.

In my trivial example, the behavior isn't terribly important either way. However, if your callback is doing something relatively expensive it may be pointless (and wasteful) to do that on a clean object. There are certainly situations where you would want it to always trigger, so I guess it's just one of those things that a developer ought to keep in the back of his mind when coding.

Vim -- :TOhtml & Customization

2009-08-17T19:10:00.007-05:00

When I first started this blog, I was surprised (and disappointed) that Google's Blogger platform didn't have some nice built-in feature for code formatting and syntax highlighting. I experimented with a number of third-party solutions, but didn't find anything that I particularly liked, so my posts have had some ugly-looking code in them. Until now.

...Well, until my previous post, anyway.

A then-coworker told me a while back about vim's :TOhtml feature, but it wasn't until last night that I actually checked it out. As it turns out, it was just what I was looking for. Out of the box, it's a little cumbersome for my purposes, but a little vim scripting helped a lot.

Default Behavior

To start, I set a few options in my .vimrc:

let html_use_css = 1 " Use stylesheet instead of inline style
let html_number_lines = 0 " don't show line numbers
let html_no_pre = 1 " don't wrap lines in <pre>

I also choose a vim color scheme I like (wombat). You can look through examples of tons of schemes here. (I spent a while trying to figure out why I couldn't set the color scheme (after I downloaded it to .vim/colors/), and the answer I found was that color schemes only work in gVim.)

So, having set some options in my .vimrc, and chosen a colorscheme in gVim, calling :TOhtml on

class Person
  attr_accessor :age

  def speak
    "Hi!"
  end

  def say_age
    "I am this many: #{'|' * @age}"
  end
end

gives:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
 <head>
 <title>~/demo.rb.html</title>
 <meta name="Generator" content="Vim/7.2">
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 <style type="text/css">
 
 </style>
 </head>
 <body>
 class Person 
   attr_accessor :age 
 
   def speak 
     "Hi!" 
   end 
 
   def say_age 
     "I am this many: #{'|' * @age}" 
   end 
 end 
 </body>
</html>

That's pretty good. If your goal was a stand-alone HTML file you'd be done, but for paste-ready output we need a little vim scripting help.

Altered Behavior

Instead of wrapping the output in a full html page, I really just want it wrapped in a div. I also want to strip out some "extra" (according to Blogger's HTML interpreter) line breaks, and pull out the CSS definitions (for later). To accomplish this, I've put together a simple vim script, which defines a new method :DivHtml

function! DivHtml(line1, line2)
 exec a:line1.','.a:line2.'TOhtml'
 %g/<style/normal $dgg
 %s/<\/style>\n<\/head>\n//
 %s/.vim_block {/.vim_block {/
 %s/<body$.*$>\n/<div class="vim_block"\1>/
 %s/<\/body>\n<\/html>/<\/div>
 %s/ //g

 set nonu
endfunction
command -range=% DivHtml :call DivHtml(<line1>,<line2>)

Now, calling :DivHtml on the ruby code above gives code I can just cut & paste into the 'Edit Html' Blogger window:

<div class="vim_block">class Person
   attr_accessor :age

   def speak
     "Hi!"
   end

   def say_age
     "I am this many: #{'|' * @age}"
   end
 end
</div>

(which renders as the ruby snippet I pasted above)

The only part of the process that is still kinda annoying is that you have to copy/paste the CSS into your header or external CSS file. Both :TOhtml and :DivHtml only output the CSS definitions for styles actually used in a snippet, so it's up to the user to check if all the definitions in a new snippet are already in your layout, or if you need to add them. The alternative would be to use inline CSS (:help :TOhtml), but that's ugly.

To finish things off, I gave the wrapping div the vim_block class, and gave that a background-color and border in my header, to make it look a little nicer. I also got rid of the "font-family: monospace" bit, because I thought it made the code hard to read.

Other than manually checking the CSS, it's a very painless process to put code snippets on the blog, and I'm happy with the look and feel of them.

Ruby on Android -- Part 2

2009-08-16T18:54:00.013-05:00

Continuing towards my goal of developing an application in ruby for my Android (see part 1), I've been getting into Rhodes, which is an open-source project that aims to allow you to build native apps for a variety of mobile platforms, all from a lightweight ruby framework. For Android, it uses xruby (not Jruby).

I started with the documentation at the Rhodes wiki, and checked out a Google Talk. I tried to duplicate the sample application in the video, but quickly starting hitting walls, which I have been trying to work through. I haven't had a ton of success with it yet, but I'll document what success I have had.

To start with, rhodes only seems to support Windows and Mac out of the box. I have forked the rhodes project, to add in linux support, as well as try to fix whatever isn't working for me (which I'll get to later). You can check out my forked rhodes my github page. The easiest way to use the repo version (rather than the gems) is to set up an alias in your bash_profile such as:

alias rh="RUBYLIB=/home/rellik/repos/rhodes/rhodes/rhodes-build/lib:/home/rellik/repos/rhodes/rhodes/rhodes-framework/lib"

Prefacing any command with 'rh ' will then use the repo version of the Rhodes libraries.

After generating an application with rhogen (found in the repo under rhodes-generator/bin/ or the rhodes-generator gem), the other platform-specific bit that you need to override is the build.yml file that gets generated for a new project. Since I'm only concerned about Android at the moment, the only line I needed to change here was the last one, to point to the android.jar that came with my SDK. For me, this amounts to:

android: /home/rellik/Desktop/android-sdk-linux_x86-1.5_r3/platforms/android-1.5

With all this, I was still not having much luck with Rhodes. I used 'rh rake run:android:app' to generate the apk and push it to the emulator. I was getting an error about no space left on the virtual SD card, but I do like having the apk be signed as part of the rake task, so I usually just run:android:app (and let it fail), then install the application manually using 'adb install -r bin/target/Rhodes-debug.apk' (the emulator must already be running).

Once the application is successfully installed on the emualator, you can slide the applications tray open and click on the Rhodes icon. You'll see a 'Loading...' screen, then a blank screen. For me, that's all there is. I tried simplifying the index.erb file, and even taking out any logic, but still I get the same blank screen. I renamed the non-dynamic index.erb to index.html, and that worked fine (I saw that page after 'Loading...'), so there seems to be something funky about rendering the ERB file.

To debug this issue, I added a series of raises and debug statements to the rake task that builds the apk, and I discovered a few things. First, the erb file gets converted to ruby, which contains the use of String#force_encoding (which is ruby 1.9). I tried downloading and using ruby 1.9 for this, as well as just taking that line out of a generated erb file, but neither helped.

Second, I left #force_encoding out, and I added "puts _erbout" as the last line of the generated erb file (bin/RhoBundle/apps/app/index_erb.rb), and then used the following to test if the generated java was any good, and indeed it was (but failed when I put force_encoding back in):

$ java -cp /home/rellik/repos/rhodes/rhodes/rhodes-build/res/xruby-0.3.3.jar:bin/RhoBundle.jar xruby.apps.app.index_erb.main
<div class="toolbar">
 <h1 id="pageTitle">
 Contacter
 </h1>
</div>

<ul id="home" selected="true" title="FirstApp">
<li>Hello Android! (This was generated dynamically and can add ten and two to make: 15)</li>
</ul>

So, that's pretty much where I am so far. I can build an app with static views, and I can confirm that the java that gets generated for my dynamic views seems ok (but won't display on the emulator, despite the apparent lack of exceptions). Maybe the force_encoding bit is the problem (that'll be my next avenue to explore).

Ruby on Android -- Part I

2009-07-21T00:45:00.005-05:00

Of course, now that I have a new G1, I want to start writing apps for it. Android apps are written in Java, but not having touched that since college, I started looking at ways to get ruby onto it instead. There was plenty of chatter about the possibility of running jruby on the device, but there are also frameworks that claim to allow you to write apps in ruby and push them to a variety of mobile platforms (android, iPhone, etc). I'll be hearing a talk about Appcelerator Titanium at Ruby Hoedown in August, but I haven't gotten into their closed beta, so I'll have to wait to try that out. The other (similar) solution I came across was Rhodes, which is available now (so that's what I'll start with).

For Android, Rhodes compiles your ruby project to an APK (Android package), which you can push to the Android emulator to test (and eventually to the marketplace). So, before I get to Rhodes, the first step is to set up a local Android development environment. I can skip a lot of the stuff Google suggests, since I won't actually be doing java work -- for this first step, all I want is to be able to take an APK and get it running in a local Android emulator. It took me a while to get this figured out, so hopefully my notes will be helpful to others.

The first step is to download the Android SDK from Google. The installation instructions include a lot of good stuff, but it most of it isn't needed for what I plan on doing. I already had Java 6 (RE) installed, which seems to work ok. Since I'm on linux, I followed the linux directions (all the way at the bottom), but the general directions for any OS amount to:

Make sure you have Java 1.5 or 1.6 installed
Install (apt-get) ia32-libs if you're on a 64-bit processor (linux only)
Set up your PATH to include the android tools. (Mac/linux: in your home dir's .bash_profile, add "export PATH=${PATH}:/tools"; Windows: right-click on My Computer, and select Properties. Under the Advanced tab, hit the Environment Variables button, and in the dialog that comes up, double-click on Path (under System Variables). Add the full path to the tools/ directory to the path.)

You can ignore all the stuff about Eclipse.

Once you have all that done, you should be able to type 'android' and see some help text (you may need to 'source ~/.bash_profile', or just open a new terminal to reread your profile and get your new PATH).

The first step is to create a new virtual device. There are currently three versions of the Android software in the SDK: Version 1.1 (the original), Version 1.5 (the current), and Version 1.5 + Google API. You can see your available targets using:

$ android list targets
Available Android targets:
id: 1
     Name: Android 1.1
     Type: Platform
     API level: 2
     Skins: HVGA (default), QVGA-P, HVGA-P, HVGA-L, QVGA-L
id: 2
     Name: Android 1.5
     Type: Platform
     API level: 3
     Skins: HVGA (default), QVGA-P, HVGA-P, HVGA-L, QVGA-L
id: 3
     Name: Google APIs
     Type: Add-On
     Vendor: Google Inc.
     Description: Android + Google APIs
     Based on Android 1.5 (API level 3)
     Libraries:
      * com.google.android.maps (maps.jar)
          API for Google Maps
     Skins: QVGA-P, HVGA-L, HVGA (default), QVGA-L, HVGA-P

You can find the details about various options when creating an Android Virtual Device (AVD) here, but the following is good enough to get you started:

$ android create avd -n first_avd15 -t 2
Android 1.5 is a basic Android platform.
Do you wish to create a custom hardware profile [no]
Created AVD 'first_avd15' based on Android 1.5

To start up your virtual device:

$ emulator @first_avd15

(I get an error here about audio input missing, but that may be because I don't have a mic on this computer.)

Now you should see a red generic Android device, with just the word "ANDROID" in the middle. On my system it takes a while, but eventually you see the "Press menu to unlock" screen, and then you can get to the home screen, where you can do normal Androidy things. To finish the test, grab a simple Android program in APK form (I used this simple app). Download it, and run:

$ adb -e install Constitution_1.0.0.apk (or whichever APK you got)
738 KB/s (534155 bytes in 0.706s)
    pkg: /data/local/tmp/Constitution_1.0.0.apk
Success

On your emulator, go back to the home screen, and you'll now the the app in the lower tray, with everything else, and it should run without incident.

If you have any problems duplicating this process, feel free to ping me (comment on this thread). I worked this out over two nights, and had many false starts, so I could have forgotten to put something that I did to get past a problem.

My next step will be try and write a simple ruby app and get it to an APK, so I can put it on my emulator.

Part 2

Vim Statusline

2009-05-21T23:17:00.002-05:00

To start off my reinvigorated vim education, I looked into why I get a helpful info bar when I have :split windows, but not when I am looking at a single file. The bar is called the statusline (:help status-line), and you can change the visibility option with

set laststatus=<#>

It defaults (on my system) to 1, meaning that it only shows for split windows. To make it always show, set it to 2.

The helpdoc informs us that you can set the content of the statusline with:

set statusline=[some string]

[some string] is a printf-style string, with a host of items it can display (:help statusline). I liked the default (with the rails.vim addition of rails filetype information), but I wanted to also see the buffer number, because I've been playing around with buffer management. Here's what I ended up with, in my .vimrc:

set statusline=
set statusline+=%<\                       " cut at start
set statusline+=%2*[%n%H%M%R%W]%*\        " buffer number, and flags
set statusline+=%-40f\                    " relative path
set statusline+=%=                        " seperate between right- and left-aligned
set statusline+=%1*%y%*%*\                " file type
set statusline+=%10((%l/%L)%)\            " line and column
set statusline+=%P                        " percentage of file

Which gives a statusline like:

[10] app/models/user.rb          [ruby][Rails-model-arb]    (1/276) Top

Vim

2009-05-21T22:58:00.005-05:00

I use vim daily for my routine development work, and I get along fine with it. When I first got into it, I scrambled up the steep learning curve until I got to a plateau where I could be productive, and haven't given it much thought since then. I can do all the basic stuff (and a few cool tricks), but other than that my editor is pretty low on the list of things I want to devote thought to.

My position changed, however, when a coworker recently decided to jump on the vim bandwagon. His daily excitement over some newly discovered command or plugin was just what I needed to reignite my interest, and I've started to climb the slopes again.

I'll share what I discover here. Most of it will probably fall in what I'd consider the intermediate level, but undoubtedly there will be some more basic stuff that I'd never come across (or taken the time to delve into). Part of my problem is that when I was originally learning vim I didn't rely on the help system (which is extensive), but instead played around with things until I was comfortable with them -- so I'll be focusing on :help a lot more this time around, to fill in the gaps. Hopefully my progress will be of some help to other vimers that have been skating by for too long.

Firebug's Console Pitfall

2009-05-12T19:12:00.003-05:00

Beware -- if you leave a reference to the 'console' object in your javascript and deploy it out, your site will not behave!

I absentmindedly deployed code with a 'console.debug()' in the javascript, and a quick test showed the site to be functioning. When I tried again in the morning (from my work computer), a dropdown was unpopulated. I enabled firebug for the site to check things out, but when the page reloaded things were fixed.

Whenever it was that I learned about the console object, I just took it for granted, and didn't bother to look up anything about it. So, not only did I not realize that it's provided by firebug (and only available when console is enabled for the site), but I also have been missing out on a variety of other cool methods off of console, such as dir(), trace(), and profile(): API

Rails Association Caching Pitfalls

2009-03-21T01:29:00.006-05:00

This week at work I was disappointed to find that calling #new on an association collection doesn't add the new instance to the cached collection:


>> patrick = Poster.first
=> #<Poster id: 1, name: "Patrick S.", created_at: "2009-03-21 03:55:17", updated_at: "2009-03-21 03:55:17">
>> patrick.posts.size
=> 0

>> new_post = patrick.posts.new(:title => "Another post")
=> #<Post id: nil, title: "Another post", text: nil, poster_id: 1, created_at: nil, updated_at: nil>

>> patrick.posts.size
=> 0

If I like the post and decide to save it to the database, my cached posts still doesn't get updated:


>> new_post.save
=> true

>> patrick.posts.size
=> 0

In order to get the collection up-to-date I have to know that this is a trouble spot, and call #reload on the association:


>> patrick.posts.reload; patrick.posts.size
=> 1

If, instead, I try to push that new instance onto the collection explicitly, it gets saved automatically, which doesn't seem very intuitive (I *much* prefer to have to explicitly save changes to the database):


>> patrick.posts << Post.new(:title => "pushing onto collection")
Post Create (0.8ms)   INSERT INTO "posts" ("created_at", "title", "poster_id", "updated_at", "text") VALUES('2009-03-21 06:14:03', 'pushing onto collection', 1, '2009-03-21 06:14:03', NULL)
=> [#<Post id: 12, title: "pushing onto collection", text: nil, poster_id: 1, created_at: "2009-03-21 06:14:03", updated_at: "2009-03-21 06:14:03">]

The right way to do this seems to be the undocumented #build, which does exactly what I was wanting in the first place (create an unsaved instance and append it to the collection):


>> patrick.posts.size
=> 0

>> patrick.posts.build(:title => 'Built')
=> #<Post id: nil, title: "Built", text: nil, poster_id: 1, created_at: nil, updated_at: nil>

>> patrick.posts.size
=> 1

>> patrick.posts
=> [#<Post id: nil, title: "Built", text: nil, poster_id: 1, created_at: nil, updated_at: nil>]
>> patrick.posts[0].new_record?
=> true

(Unfortunately, there seems to be a related problem with the association's #delete/#destroy)


>> patrick.posts.size
=> 2

>> patrick.posts.last
=> #<Post id: 13, title: "Another", text: nil, poster_id: 1, created_at: "2009-03-21 06:19:55", updated_at: "2009-03-21 06:19:55">

>> patrick.posts.last.destroy
=> #<Post id: 13, title: "Another", text: nil, poster_id: 1, created_at: "2009-03-21 06:19:55", updated_at: "2009-03-21 06:19:55">

>> patrick.posts.size
=> 2
>> patrick.posts.reload; patrick.posts.size
=> 1

Watching Your Logs From The Console

2009-03-16T01:44:00.011-05:00

I've often wished there was a way to see the rails logs right inside the console window, instead of having to switch back and forth betweeh console and a "tail -f" process. It wasn't hard to find an answer -- Jamis Buck blogged about it back in 2007 -- but it didn't quite do all I was hoping for, so I ended up going a different route, which I think gives a more complete solution.

The solution that I saw on Jamis' blog was to replace wholesale the rails logger:


ActiveRecord::Base.logger = Logger.new(STDOUT)

The problems with this are:
1) It must be done before any AR::Base logging is done, and
2) It cannot be undone.
(Both due to the logger object being cached)

For my needs, I'm interested in the logs for a particular method call, but I don't really want to see all the logs, all the time. So, I wrote the code that follows (at the end of this post), and put it in my .irbrc file. It gets around the cached logger object by altering the logger, rather than trying to replace it. This allows me to turn it on or off mid-session. For example (from a personal side project):


>> wr = WeightRecord.first
=> #<WeightRecord id: 1, date: "2007-10-28", weight: 177.0, ... >
...  # More commands, which I don't care to see the logs from ...
>> wr.weight = 176
=> 176

>> show_log
=> nil
>> wr.save
SQL (0.000154)   BEGIN
SQL (0.069810)   SELECT `date` FROM `weight_records` WHERE (`weight_records`.date = '2007-10-28' AND `weight_records`.user_id = 1 AND `weight_records`.id <> 1)
WeightRecord Update (0.000688)   UPDATE `weight_records` SET `updated_at` = '2009-03-16 01:04:08', `weight` = 176.0 WHERE `id` = 1
SQL (0.004874)   COMMIT
=> true

>> hide_log
=> nil
...  # More stuff I don't need to see the logs from...

(The "SELECT `date`" bit in the logs is because my model has: "validates_uniqueness_of :date, :scope => :user_id")

The code:


def show_log
  unless @log_buffer_size
    @log_file = Rails.logger.instance_variable_get("@log")
    @log_level = Rails.logger.level
    @log_buffer_size = Rails.logger.auto_flushing
  end
  Rails.logger.flush
  Rails.logger.instance_variable_set("@log", STDOUT)
  Rails.logger.level = Logger::DEBUG
  Rails.logger.auto_flushing = 1
  nil
end

def hide_log
  if @log_buffer_size
    Rails.logger.instance_variable_set("@log", @log_file)
    Rails.logger.level = @log_level
    Rails.logger.auto_flushing = @log_buffer_size
  end
  nil
end

When Your Data Leaves Home Without You

2009-03-04T02:23:00.001-06:00

Those that know me best know that I much prefer to keep my data on my own servers, as opposed to using services such as PicasaWeb, Blogspot, and github. Something about giving up possession of my original content doesn't sit quite right with me -- maybe it's my own experience with the "possession is nine-tenths of the law" adage, or maybe I'm just wary of free services. There's also the problem of building up a brand that is on someone else's domain -- whatever popularity my content gets should be associated with my domain, not the provider's. Whatever the reason, I am generally willing to put up with poorer performance (etc.) in order to host my services myself.

For my two new blogs I started out looking for a rails plugin, to add into plainlystated.com. I didn't find anything that looked mature, and I didn't feel like coding it myself (since these things always end up taking a lot longer than they initially seem when you add in captchas, admin features, layouts, etc). I got the latest version of Typo, but it was running at almost 60 megs of RAM, which is a lot for my little VPS. Plus, "satellite blogs" (two separate blogs running on one Typo) aren't even supported "yet", so it was gonna be a matter of hacking Typo (maybe with a third-party plugin), or running two instances, and both options seemed like a waste of semi-precious resources.

So, as you can see, I broke down and went with a free hosted solution. I looked briefly at wordpress, blogspot, and livejournal, but they all seem "good enough" so I went with ole' reliable: Google.

In this case, there seem to be some substantial benefits to going with Blogspot:

I don't use my own resources,
I don't have to worry about security, system maintenance, etc.,
I get automatic security updates and feature upgrades,
I get plenty of free templates,
It "just works".

Blogspot also provides the option to host the blog from a subdomain of your own (which is how I have techspeak.plainlystated.com instead of techspeak.blogspot.com), which is pretty cool, and mitigates my concerns about building up my own brand.

Hopefully this decision will end up making me more comfortable with taking advantage of all the great free providers out there (maybe I'll be linking to a PicasaWeb album before long).

New Blog

2009-03-03T02:14:00.000-06:00

Just a quick post to introduce my new blog... This, along with my other new blog forthright.plainlystated.com (non-technical) are meant to be my new home in the ether.

This blog (techspeak.plainlystated.com) will generally be about my adventures in Ruby on Rails, as I continue growing my expertise in the field. (I have been working professionally with Rails for about 2 years, including the past 1.5 years at Medical Decision Logic working on medical research management software.)