Today, I just found out there is a Ruby Development Toolkit (RDT) plugin for my favourite IDE… Eclipse! Sweet! The toolkit is downloadable via Eclipse Software Update, the remote site URL is:

http://updatesite.rubypeople.org/release

Features supported are syntax highlighting, on the fly syntax check, graphical outline, Test::Unit view/runner, Ruby application launching, content assist, source formatter, Ruby debugging, Type Hierarchy view, Ruby specific Search, Refactoring, and much, much more…

There are all new features described with an example. It’s quite amazing to see how rails evolves.
btw: did you know that there is finally an i18n patch in edge rails, to be released with rails 2.2? this is a solid foundation for other plugins to build on.

I must admit that there are still some issues like: No ruby code on multiple lines to format the code properly on very long ruby statements. And: HAML source code highlighting in netbeans plugin is quite old and not updated, but this doesnt stop me from using it.

just checkout the “showdown” on the bottom of the first page to get a feeling of HAML.

But how do we integrate this nicely into our rails app? The following solution might not be perfect but that's what i'm using and like:

put the css file from Deathshadow
in your public/stylesheets dir.

in your erb view, include the css with:

then add the following helper methods to the entire application:

to let this work we still need to definde the proper css classes as explained on the rounded corners web page:

now in any of your views you can do fun stuff like:

or with a nice border around the div:

but also inside your view helpers you can generate rounded divs with pure ruby:

1. Send your images to their service (existing image via URL or encoded as multi-part)
2. Then the user modifies the picture (size, colors, rotation, special effects...)
3. Picnik sends you the picture back to your server (either an URL where you can download it or directly as multi-part image)

Here comes an example I have built for demonstration...Click on the picture below to edit it.

Everything realized by using a link to this URL:

Pretty cool isn't it? Thats the basic example but you can customize a lot more (see their API). Also I didn't progress the picture back on my server.

If you want to get started i recommend to start with their tutorials. They are nicely written and done in 10 minutes.

Bung this snippet into a file in your applications lib folder and don't forget to require it within the environment.rb (Alternatively you could use the new initializers of Rails 2.0).

After that you can do the following to your ActiveRecord models:

Now the attributes firstname and lastname will never ever hold values including whitespaces in front and the end. Note: the cat is still alive ...


"\M-[": "["
"\M-]": "]"
"\M-{": "{"
"\M-}": "}"
"\M-\\": "\\"
"\M-|": "|"
"\M-@": "@"
"\M-~": "~"
"\M-?": "?"


save this to e.g. c:\.inputrc and put the following to your irb.bat (which is usually located in c:\ruby\bin\) straight after the @echo off line:

SET INPUTRC=C:\.inputrc

Now you should be a more happier Rails dev.. At least i am. (I found this information at flip's blog - Thanks!)

(i've used code sections to create more sections.)

1. ensure that invalid values result in an error for the tested attribute (e.g. age -2 is invalid, so the instance should hold an error for the attribute age)
2. and valid values don't result in an error for the tested attribute (e.g. age 20 should be fine)

Usually you should test a couple of invalid values and a couple of valid values against each attribute of your model. This can be quite a lot to code. I explain a nice approach how to speed things up and save time for the next family event.

(Code below has been tested with Rails 1.2.5 and Rails 2.0.1) Let's say our User class looks the following:

I don't go too much into detail about this. Simply: It's a User which is bound to a Users database table and includes three validations:

• the firstname should have at least 2 chars and maximum 255
• the firstname should have at least 3 chars and maximum 255
• the age must be a number greater than 0 and maximum 100

Best case would be if we completele test the User model for the following cases (testing that wrong values fail and correct values don't fail):

• valid firstnames: michal, tom, John, Jennifer K, David
• invalid firstname: nil, J, ''
• valid lastnames: gabrukiewicz, Aniston, Heinemeier Hansson
• invalid lastnames: nil, gr, t, ''
• valid ages: 1, 10, 20, 73
• invalid ages: nil, '', 0, -10, -36, x, 7sz, 101, 120
• creating a valid User and successfully saving (not described in this article)
• get an existing user, modify some attributes and save (not described in this article))

Here we defined what is wrong and what not (what is even better: you could write this tests even before you write your User model). In order to do the bulk testing I have written a helper method which will do the stuff for us in a Rails-way. We put this method into our test_helper.rb so its available to all our test cases:

You see that the method expects the attribute we want to test (attr), the tested values (vals) and what we expect the values to be (expecting) - valid or invalid. Furthermore you see that the tested model is taken from the instance variable (@model) which will be taken from your individual test case (placed into the setup method). Thats to stick with DRY (cause every unit test deals with one model). Last but not least the helper asserts with a nice error message which eases us up to find the problem .. if there is one.
Ok enough, we can use this now for the test of our User. Rails generated the UserTest for us when we generated the model. We test our attributes firstname, lastname and age. All for validity and invalidity.

Thats nice but at this point we stop. We are not testing lastname and age anymore because before we do so we DRY this a bit up. We add another helper method which uses our existing attr_test and tests the invalid and valid values in one go. After that we sit back and watch our tests run. Bung this method into your test_helper.rb ..

with this we are ready to rock our User class. See the full test now...

That's it if the tests were successful then your model is working fine. If not then you will see helpful messages in your console which will indicate what went wrong during the attributes test.

I strongly recommend you to test all your models against the functionality you will use in your application(s) (all public class members). This takes a bit of time but it let's you sleep better after doing any upgrades, enhancements, bug fixes etc. And don't forget: never cheat on yourself when writing tests! you are writing them for you ...

• checks if email is syntactically correct (using regex)
• checks if the host of the email is supported within the application. This is very important for me because I dont want ppl signing up with one-time emails from e.g. mailinator.com. (can be disabled)

For this we create a validations helper module which holds all our custom validations. We can then inject them into our models where necessary. The following code should live in /helpers/validations_helper.rb in order to be loaded automatically:

If you now want to validate e.g. the email attribute of a User model, do it like you used to do with the existing validators:

It still supports all the options which you know from all other validators. So you can specify your own message with :message, use a condition with :if, etc. There is one additional option :allow_all_hosts which prevents the validator to check against the disallowed hosts (all email hosts would be allowed then).

have fun with it and feel free to comment improvements, suggestions, comlaints, etc...

if you are looking for more validators and/or more information about them check Custom validations in rails from Greg

michal - RaRoR (rock and roll ruby on rails)