RemVee.blog

Ik ben een simpele web applicatie met rails aan het bouwen. Niets bijzonders; wat berichtjes, een gastenboek en wat formulieren. Deze laatste formulieren hoeven niet opgeslagen te worden maar moeten verstuurd worden via e-mail. Dat versturen is geen probleem; recht toe recht aan ActiveMailer. De uitdaging zit hem in het valideren van deze formulieren.

Uitdaging is misschien een beetje sterk uitgedrukt maar als je net het beheer van berichten met ActiveRecord hebt gebouwd, is het een beetje jammer als je dan toch weer dingen gaat schrijven als:

if params[:email].nil? || !EMAIL_PATTERN.match(params[:email])
  @errors[:email] = 'E-mail adres moet correct ingevuld worden.'
end

Neeh, daar pas ik voor! Ik wil gewoon form.valid? kunnen vragen zoals bij ActiveRecord objecten. Maar hoe doe je dat?

Yay! Ik ben de trotse stichter van de EXIF Reader gem, een simple module om EXIF tags uit JPEG te lezen. Alle moderne digitale camera welke JPEG’s maken, gebruiken EXIF tags om informatie over de genomen foto op te slaan zoals sluitertijd, diafragma etc. Allemaal essentieel als je een foto album applicatie aan het bouwen bent en wat moet je anders doen als je blog applicatie “af” is. ;-)

In de volgende versie van rails (1.1) worden veel nieuwe dingen geïntroduceerd. Zie voor een continue groeiende lijst het blog bericht van Scott Raymond. Er zitten waanzinnige dingen bij en ik hoop snel weer tijd te hebben (ik zit nu in een verhuizing) om met al dat moois te spelen.

M’n favoriet is delegate. Het is zo’n juweeltje, dat zó voor de hand ligt dat ik me meteen af vroeg waarom dat niet gewoon in ruby zit. Voorbeeldje:

Address = Struct.new(:city, :country)
class Person < Struct.new(:name, :address)
  delegate :city, :to => :address
end

remco = Person.new('remco', Address.new('Amsterdam', 'Nederland'))
p remco.city # => "Amsterdam"

Dus; definieer twee classes Address en Person waar Person een Address bevat en geef in Person direct toegang tot het city attribuut.

Vorige week donderdag en vrijdag heb ik met Michiel de Mare aan de RAD race meegedaan met Ruby on Rails. Lees er meer over op de RubyEnRails.nl.

Commandline utilities hebben vaak korte namen; ls, rm, grep, svn etc. De subversion client svn heeft (sub-)commando’s welke allemaal afkortingen hebben; svn status kan je schrijven als svn st e.d. Toen ik een ruby wrapper class had geschreven om het svn commando, miste ik metteen de svn st variant. Natuurlijk kan je gewoon wat aliases aanmaken voor commando’s maar ik zag een kans voor een experimentje in een verloren uurtje.

Bladerend door de appendix van pickaxe 2 ben ik ooit tegen abbrev aangelopen. Gegeven een lijst termen geeft deze een hash van mogelijke afkortingen terug:

require 'abbrev'
require 'pp'
pp %w{bla die foo bar}.abbrev

levert:

{"die"=>"die",
 "bla"=>"bla",
 "d"=>"die",
 "di"=>"die",
 "foo"=>"foo",
 "f"=>"foo",
 "bar"=>"bar",
 "ba"=>"bar",
 "fo"=>"foo",
 "bl"=>"bla"}

Mooi om automagische afkortingen te leveren. We kunnen aan de slag!

In een poging DRY te blijven, ben ik in de wondere wereld van ruby meta programmeren terecht gekomen. Het was er mooi en dat wil ik graag delen.

Ik was bezig met het maken van een subclass van String, Html. Mijn variant kan wat specifieke manipulaties uitvoeren: absolutize(url) om alle links absolute te maken, escape om speciale tekens te vervangen en sanitize(tags = nil) om tags, welke niet toegestaan zijn, te verwijderen. Na de methoden geschreven te hebben en een TestCase aangemaakt, bedacht ik me dat ik ook een !- (past het daadwerkelijk object aan) en self.-variant (class methode waar een String object ingaat en gemodificeerde versie uitkomt) wil hebben.

Ik heb eerst alles omgeschreven naar een !-variant, m’n code werd hier eigenlijk veel duidelijker van; geen value.gsub!(.. meer maar gsub!(... En ik ben m’n varianten gaan toevoegen:

  def escape
    result = dup
    result.escape!
    result
  end

  def self.escape(value)
    result = Html.new(value)
    result.escape!
    result.to_s
  end

Ho wacht! Moet ik die nu voor alle drie de methoden doen?! Maar dat is niet DRY! Ik wil kunnen schrijven:

  def_variants :escape

Als Java professional ben ik verknocht aan de refactoring mogelijkheden van Eclipse. Sterker nog de reden waarom ik van Vim en commandline CVS overgestapt ben, is refactoring. M’n grootste zorg bij de stap naar Ruby is het missen van dergelijk tools. Ik heb ze nog niet gemist maar dat is ook niet zo gek als je pas een half jaar over Ruby obsedeerd en nog geen honderden kilobytes code hebt die eigenlijk anders moeten.

Gelukkig ben ik niet de enige die zich daar zorgen over maakt en zijn er veel slimmere mensen die allang oplossingen hebben gevonden. Via een blog bericht van Curt Hibbs kwam ik op een uitgebreid verhaal van ene Murphee en daar vandaan op een waanzinnig Ruby-eske oplossing van Mike Williams. M’n hartje sprong!

Als je bezig bent met web applicaties loop je vaak tegen het probleem dat het lastig is om de grootte van een afbeelding te bepalen. Voor GIF’s en PNG’s is dat triviaal maar JPEG’s zijn lastig. Ik heb wat oude code geport naar Ruby en kan nu zonder afhankelijk te zijn van een of andere library JPEG’s lezen.

Fueled by a post by Danny. My take on the Java versus Ruby hype.

I am growing more and more tired of the comparison between Java and Ruby. They just don’t match.

Oh, we willen natuurlijk ook de andere kant op kunnen! Voeg het volgende toe aan de uitgebreide Fixnum:

class Fixnum

…

  @@ROMAN_HASH = Hash[*@@ROMAN_DIGITS.map{|a,b|[b,a]}.flatten]

  def self.from_roman(txt)
    result, last = 0, 0
    txt.upcase.reverse.each_byte do |c|
      n = @@ROMAN_HASH[c.chr] or raise "'#{c.chr}' is not a valid roman digit"
      result += n < last ? -n : n
      last = n
    end
    result
  end
end

En nu kan je met Fixnum.from_roman('MCMLXXII') weer terug naar 1972!