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

His 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: <b>#{@user.name}</b>", :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

Typically, developers tend to forget to turn off view state resulting in a lot of data that never is used. The guy who made the decision to have this default view state behaviour has probably caused a lot of unnecessary bytes clogging your internet connection (as it typically is included in each request).

If you are using mechanize and/or Hpricot to parse such a site you may have come across this error:

ran out of buffer space on element <input>, starting on line 38. (Hpricot::ParseError)

If you want to try it out, load this sample viewstate file into Hpricot. The buffer space error has been reported in the Hpricot issue tracker.

Fortunately, from version 0.5 of Hpricot it is easy to increase the buffer size before loading data. This is done by setting the buffer_size attribute to a sufficiently large number:

require ‘hpricot’
Hpricot.buffer_size = 262144

Fixing Mechanize

As mechanize uses Hpricot as the default parser this error will happen when loading many ASP.NET pages. Fortunately, mechanize allows the user to specify a custom parser class through the pluggable_parser attribute. To make mechanize use Hpricot with a larger buffer size:

require ‘hpricot’
require ‘mechanize’

Hpricot.buffer_size = 262144
agent = WWW::Mechanize.new
agent.pluggable_parser.default = Hpricot
agent.get(‘http://www.peterkrantz.com/wp-content/uploads/2007/02/viewstatesample.htm’)

…and we’re back on track mechanizing the world again.

Recently I had a situation where I needed to parse a 700 Kb XML file and extract some values with XPath queries. Doing this in REXML proved to be too slow (around 30 seconds). Since I was on OS X it was a small task to get the Ruby libxml bindings. The speed increase was immense and everything worked smoothly.

As usual, requirements change and the application needed to be able to run on Windows and OS X. Unfortunately the Ruby libxml api does not work in Windows. Looking around, I couldn’t find a decent XML parser for Ruby that worked on both platforms and I didn’t want to code for both REXML and libxml.

Enter Hpricot. Originally written to do HTML scraping it is actually very capable of working with XML too. And it has binaries for Windows, Linux and OS X.

A quick example shows how easy it is to load and get data from an XML file:

require ‘hpricot’
doc = Hpricot(open(“lazaridis_msgs.xml”))

doc.search(“//message”).each do |message|
e_number = message.attributes["subject"][16..17]
puts “Evaluation identifier is #{e_number}”
end

Technically, Hpricot isn’t an XML-parser. It doesn’t validate the document which means that malformed XML can slip through. You will have to be careful if your application relies on wellformedness of the XML data.

I will be switching the Ruby Accessibility Analysis Kit over to Hpricot soon. It will be a nice speed increase for your Rails unit tests using RAAKT. This will also solve the problem in RubyfulSoup where the author declared a “Tag” class with a bad scope.

So, maybe I am the last person on earth to discover this, but if you need a great library for XML parsing on multiple platforms, check out Hpricot.

So, using iremoted and capture Apple remote commands in the terminal it is trivial to use the remote to control a Ruby application. Of course, calling OS commands isn’t limited to Ruby.

Here is a minimal dungeon game which you control with the apple remote. If you ever manage to find your way out I would be surprised…

IO.popen (“/Applications/iremoted”) { |f|

x = y = 0

puts “You are standing in an open field west of a white house, with a boarded front door…”

while (line = f.gets.chomp)
if line == “Plus released”
y += 1
end

if line == “Minus released”
y -= 1
end

if line == “Previous released”
x -= 1
end

if line == “Next released”
x += 1
end

puts “You are at coordinate #{x}, #{y}.”
end
}

Who will be first to create a terminal based media center application using Ruby? With some more glue from RubyOSA (the Ruby/AppleEvent Bridge) it should’t be that hard.

Fortunately you can easily change the behaviour by editing the open-uri source. If you are on Windows it is available in C:\ruby\lib\ruby\1.8\open-uri.rb depending on your installation directory of course.

Somewhere around line 232 (in the version distributed in Ruby 1.8.5) you can see the certificate verification mode used:

http.verify_mode = OpenSSL::SSL::VERIFY_PEER

To skip certificate verification you can change VERIFY_PEER to VERIFY_NONE. The complete section should read:

if target.class == URI::HTTPS
require ‘net/https’
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
store = OpenSSL::X509::Store.new
store.set_default_paths
http.cert_store = store
end

• I hate Java
• Java sucks
• Python sucks
• I hate Microsoft
  
• I hate DTDs (that is REXML by the way…)

Interestingly, searching for “Ruby sucks” does not return any matching documents…

“…there is a systematic relationship between the grammatical categories of the language a person speaks and how that person both understands the world and behaves in it.”

Recently I have found more information on how other people feel programming languages influence how they think (e.g. Paul Graham, Charlie Savage). Maybe this can put an end to the Ruby vs Python debate? Some people will feel that Ruby relates more to their thought process than Python does. And some will feel that Python is superior.

If you like me believe that programming languages influence your thought process the advice in The Pragmatic Programmer: From Journeyman to Master is very relevant:

“Learn at least one new [programming] language every year. Different languages solve the same problems in different ways. By learning several different approaches, you can help broaden your thinking and avoid getting stuck in a rut.”

Others may disagree.

So, what is your next language?

Install the RAAKT gem

This is a simple step. If you have installed rubygems all you need to do is gem install raakt. This will install the latest version of RAAKT (currently 0.3).

Add the custom assertion

Open the file test_helper.rb in the test folder in your Rails application. Add the following method to the class Test::Unit::TestCase:

def assert_basic_accessibility
rt = Raakt::Test.new(@response.body)
result = rt.all
assert result.length == 0, result.collect { |msg| “n” + msg.text + “n” }
end

Make sure the raakt module is required by adding “require ‘raakt’” in the top of the file. No we can use assert_basic_accessibility in our functional tests (where view output is available).

Test your views

By adding assert_basic_accessibility to all functional tests that render a complete HTML document you can make sure you don’t create any of the fundamental accessibility errors that plague many applications.

Currently the RAAKT module will do the following tests on your markup:

1. check_document_structure: Verify that headings are correctly structured (h1 -> h2 etc)
2. check_tables: Verify that all tables have headers (th elements).
3. check_for_formatting_elements: Make sure no font, b, i, blink or marquee elements have been used.
4. check_has_heading: Verify that the document has at least one h1 heading.
5. check_form: Verifies that all form input fields (except hidden fields) have a corresponding label element.
6. check_link_text: Verifies that all link elements are unambiguous (two links with different targets should not have the same link text. Yes, that means all your “Edit” links). Use the title attribute to separate links.
7. check_title: Verify that a non-empty title element is available.
8. check_frames: If frames are used, verify that each frame has a descriptive title attribute.
9. check_images: Verify that all images have an alt attribute.
10. check_refresh: Make sure that no client-side meta refresh is present.
11. check_for_nested_tables: Verify that no nested tables are present.
12. check_for_language_info: Make sure the html element has a lang attribute indicating what language your document is in.

Sometime soon I will create documentation on each of the errors that you may recieve and what you can do to correct them. Suggestions and feedback are always welcome on the RAAKT project page.

Having recently recieved a brand new MacBook Pro from my employer I needed to get basic things such as mail and calendaring working. We use Microsoft Exchange 2003 which is great if everyone is using Outlook. Since I work with various clients I am subjected to their respective firewall policy which typically only allows HTTP(S) traffic. This leaves us with Outlook Web Access (dumbed down interface for everyting but IE). Reading e-mail works fine in OWA. However, the calendar becomes useless as reminders won’t appear.

Unfortunately, Apple’s iCal doesn’t work with Exchange. iCal does, however, store data in the standard icalendar format. Having som experience working with WebDAV access to Exchange (which is available if you can reach OWA) I decided to write an Exchange API in Ruby to read calendar items and convert these to the icalendar format. So, I was about half-way through when I discovered that Sam Smoot had created RExchange. That gave me most of the API:s required for connecting to Exchange.

RExchange did not contain a class for working with appointments (only mail and contacts), so I had to add that. Also, RExchange uses the Time::parse method to convert strings to time representation which doesn’t work for dates after 2037.

Anyway, to export your Exchange calendar to iCal through WebDAV, download the rexport script, unpack the files and modify the rexchange.rb file with your login credentials and OWA URL. Execute rexchange.rb from the terminal. It will create an iCal storage file corestorage.ics in the same directory. This can be opened directly in iCal.

Future options may include a synchronization mode. Suggestions and patches are welcome.