class Organization(models.Model):
    name = models.CharField(max_length=255)
    url = models.URLField(verify_exists=False)
    orgtype = models.ForeignKey(OrgType)

The same model class in Rails typically looks like this:

class Organization < ActiveRecord::Base
    belongs_to :OrgType
end

…and in Grails it is more specific like Django:

class Organization {
  String name
  String url
  static belongsTo = OrgType
  OrgType orgtype
}

It took me a while to remember that in Rails, parts of the model design is actually stored in the database schema instead of in the Ruby code. Peculiar don’t you think, given that everything else in a Rails app is nicely declared in Ruby code? There are of course benefits to both approaches, but I have started adding comments in the Rails model classes to be able to remember what properties they have without peeking in the Db. Typically I have a number of half-baked projects on my laptop and from time to time I forget what they do and these comments help me remember.

Check out more examples here:

• Django models
• Rails models
• Grails models

$a = 0;
$b = "eggs";
$c = "spam";

yields:

a == b
b != c
a == c
a == d
b != d
c != d

(Please note that d hasn’t been defined). In the comments, people freak out and tell him that this behaviour is defined in the documentation. I guess that makes it even worse.

Trying the same thing in Ruby:

a = 0
b = “eggs”
c = “spam”

a == b
=> false

b == c
=> false

a == c
=> false

a == d
NameError: undefined local variable or method ‘d’ for main:Object from (irb):7

SimpleCrawler is a Ruby gem that covers basic web crawling needs. Coupled with Raakt and Ruport it can be used to create a basic accessibility report for a website.

A minimal example:

require ‘simplecrawler’

# Set up a new crawler
sc = SimpleCrawler::Crawler.new(“http://www.peterkrantz.com/”)

sc.crawl { |document|
# output the crawled uri
puts document.uri
}

For more details and examples see the SimpleCrawler wiki.

The Hackety Hack

Hi latest endeavour seemed uninteresting at first. Hackety Hack, a toolbox to teach programming to kids. But after a while it dawned on me. If Ruby on Rails is beginning to make inroads into the Enterprise by challenging web development paradigms, Hackety Hack will in time question many of the programming paradigms taught at universities today.

My first programming class at university was in ML, a functional programming language. I remember that we played with lists a lot. And recursion. Then we made a parser for our own symbolic programming language. I guess that pretty much killed my entrepreneurial spirit for a couple of years.

Kids who learn how to set up a blog in five lines of code, send messages over the internet and play with mp3 files will not accept that. The first kids out of Hackety Hack camp will soon be arriving at universities all over the place. And they will question the curly braces, the semicolons and Arcane ways to make Old programming languages Pleasant.

If I was a university professor I would make sure to have a look at some other programming languages apart from Java and C# (do they teach C# at universities?) before these kids come and ruin my programming classes.

I predict that Sweden will be the last bastion of uninterested software developers. To make some sort of vague statement I have made a Hackety Hack t-shirt for my 2 year old son. I hope he will be at the front lines of the Hackety Hack revolution.

Update: A bunch of people asked me where the highres print came from. The original logo is of course from Why the lucky stiff. Here is the Hackety Hack logo PDF that I created in Inkscape.

Let’s say you have the following migration code:

class InsertCounties < ActiveRecord::Migration
def self.up
County.create :code => ’10′, :name => ‘Blekinge’
County.create :code => ’20′, :name => ‘Dalarna’
end
end

This assumes that the County model is available when the migration is run. If you checked out the most recent version of your code from svn it is possible that it doesn’t contain the County model and the migration will fail. To check if County is available before trying to use it we can use Ruby’s defined? like this:

Update: No we can’t. defined? always returns false inside an ActiveRecord migration for some reason (maybe the class isn’t loaded before the actual call?). We have to use a begin…rescue…end block instead:

class InsertCounties < ActiveRecord::Migration
def self.up
begin
County.create :code => ’10′, :name => ‘Blekinge’
County.create :code => ’20′, :name => ‘Dalarna’
rescue
puts “Could not add data…”
end
end
end

This way the rest of the migrations will run.

Ola Bini is also concerned about Microsoft not letting ther developers look at the Ruby implementation. If you remember the whole SCO debacle I guess it isn’t that strange. Microsoft is in the position where software they develop potentially may end up in millions of computers. Apparently the US legal system awards damages in proportion to this. Thus, any issues with a Ruby implementation on .net can quickly become costly.

It is all quite bizarre. Does this mean that the Microsoft version of the Ruby language is different from the “original” Ruby? I guess we will never know. Developers will probably write a lot of Ruby code that runs happily on the CLR. Rails applications will be deployed. But I am sure that there will be “special cases” where IronRuby will differ from “original” Ruby.

Therefore is was refreshing to see that Queensland University of Technology are progressing steadily with their Ruby.NET implementation. Currently you can actually compile a Ruby script into a .NET 2.0 assembly that other CLR languages can talk to. This may be the spearhead into the other half of enterprise deployment options.

All in all the future of software development looks bright. Will developers that invested a lot of time in Java or C# switch? Or will they move on to maintaining applications?

Part of the problem lies in the fact that the PDF specification (at least up to 1.6) does not support UTF-8 (you can use UTF-16 if you like). I had the misfortune of plowing thorugh it a couple of years ago when developing a PDF form filler library for a customer (don’t ask).

In Ruby on Rails, this is easy to solve as long as you only use Latin characters with diacritics. The solution is to switch encoding back to ISO-8859-15 for text strings you feed to PDF::Writer.

A simple extension to the String class will do the trick:

class String
require ‘iconv’
def to_iso
c = Iconv.new(‘ISO-8859-15′,’UTF-8′)
c.iconv(self)
end
end

If you are working in Rails you can put this code in the lib folder (I usually call the file string_extensions.rb).

Then, when you call the text method on your PDF::Writer intance you can easily pass a correctly encoded string.

Overriding PDF::Writer text method

A much cleaner approach, as Aníbal describes in the comment below, is to override PDF::Writer’s text method.

Put the following code in a file called pdfwriter_extensions.rb (or whatever you choose to call it) in your lib directory:

CONVERTER = Iconv.new( ‘ISO-8859-15//IGNORE//TRANSLIT’, ‘utf-8′)

module PDF
class Writer
alias_method :old_text, :text

def text(textto, options = {})
old_text(CONVERTER.iconv(textto), options)
end

end
end

In your controller that handles the PDF output you add:

require ‘pdf/writer’
require ‘pdfwriter_extensions’

…after which you can use PDF::Writer like in the tutorial:

pdf = PDF::Writer.new
pdf.select_font “Helvetica”, :encoding => nil
pdf.text “User name: #{@user.name}“, :font_size => 16, :justification => :left
send_data pdf.render, :disposition => ‘inline’, :filename => “user_details.pdf”, :type => “application/pdf”

This means that there is no reason to skip basic accessibility testing of whatever you are developing! To find out more on how you can integrate Raakt in your testing framework check out the Raakt wiki which now has a lot more information.

To install the new version simply type gem update raakt or gem install raakt if you have a previous version installed.

Changelog

Summary of changes from version 0.4 to version 0.5.1.

• Example of how to use RAAKT in Watir unit tests.
• Tests for area element alt attribute.
• UWEM mapped in comments for relevant test methods.
• Test to check that input fields of type image have an alt attribute with text.
• Refactoring of some methods for more compact syntax. Patch by Derek Perrault.
• Added test to verify that fieldsets have legends.
• Fixed alt_to_text that needed to check element type before attempting to read attribute value.
• Fixed language attribute check (downcased value). Added iso language code list.
• Applied patch from Derek Perrault (better use of Hpricot features).
• Fixed check for lang attribute (now requires a value as well).
• Test for charset mismatch in http headers and document meta element.
• Switch to Hpricot. Patch by Derek Perrault.

An article on the value of, and how to integrate basic accessibility tests in your development process is in the works for standards-schmandards.com. In the meantime check out the Raakt wiki.

If you are using Watir it is very simple:

require ‘watir’
require ‘raakt’
require ‘test/unit’

class TC_myTest < Test::Unit::TestCase
attr_accessor :ie

def setup
@ie = Watir::IE.start(“http://www.peterkrantz.com”)
end

def test_startPagePassesBasicAccessibilityCheck
#set up the accessibility test and pass html to raakt
raakttest = Raakt::Test.new(@ie.document.body.parentelement.outerhtml)

#run all tests on the current page
result = raakttest.all

#make sure raakt didn’t return any error messages
assert(result.length == 0, result)
end
end