Christoph Olszowka

Testing inbound mail with the mail gem

2011-03-29

Photo by eole

The mail gem has become the underlying library of Action Mailer with Rails 3, replacing TMail, but it's also capable of receiving email from a POP3 or IMAP account. I couldn't find any documentation for testing the retrieval, so I figured it out from the source - here's how you can test your inbound mail processing.

Instead of the POP and IMAP retrievers, you need to use the TestRetriever. To set it up, you'll just have to configure the retriever_method to :test, like this:

Mail.defaults do
  retriever_method :test
end

The "inbound mail" you'll be fetching is coming from the class method Mail::TestRetriever.emails, which is a plain array and is supposed to be fed with Mail instances which you'll obviosuly need to create either manually or by reading in a previously dumped email in the eml Format:

manual_mail = Mail.new do
  from "someone@example.com"
  to "someother@example.com"
  subject "Fancy Test Mail"
  body "Oi!"
end

dumped_mail = Mail.read('/path/to/message.eml')

Then, just add the mail to your inbound email collection:

Mail::TestRetriever.emails << manual_mail
Mail::TestRetriever.emails << dumped_mail

Calling Mail.all should now yield the test mails, so your mail processing code should process them as expected. Of course you could also use ActionMailer to generate your test messages: MyMailer.some_mail returns a plain Mail message instance.

Putting it together

You'll probably also want to reset the test email collection in a teardown method, so a basic test/unit test for inbound mail processing might look somewhat like this:

class InboundMailTest < Test::Unit::TestCase
  def setup
    Mail.defaults { retriever_method :test }
  end
  
  def teardown
    Mail::TestRetriever.emails = []
  end
  
  def test_inbound_mail
    receive_mail('examplemail')
    # This class being your inbound mail processor.
    # Implementation left as an excercise to the reader ;)
    assert MyMailProcessor.process
    # more assertions that test the results of your mail processing...
  end
  
  private
  
    # Read in email from a prepared fixture file in eml format and push it to the 
    # inbound mail q
    def receive_mail(fixture_name)
      Mail::TestRetriever.emails << Mail.read("fixtures/mails/#{fixture_name}.eml")
    end
end

Setting up your custom Hoptoad Notifier endpoint for free using Errbit on Heroku

2011-02-22

The Errbit app is an open source Rails 3 app that is API-compatible with Thoughtbot's Hoptoad Notifier and thus allows you to roll your own exception tracking service for free on Heroku. Let's see how to set this up.

You may have various reasons to roll your own exception tracker. Be it the need for customization (either visual or functional), security concerns or simply the price-tag of commercial exception trackers.

For me, it's mostly the security concerns. Hoptoad only offers SSL for plans starting at $15/month, and thus plenty of people send their application errors across the world in plain text - including environment configuration like S3- and mail credentials.

Of course, relying on your own error service gives you adminstrative overhead which you might not want. It's up to you to decide what suits you better - this article is only here to explain how you can set up the great Errbit app on Heroku with SSL enabled for free in a matter of minutes.

If you're curious what this might look like, check out the screenshots in the Errbit announcement post here.

Cloning and configuring Errbit

Let's start out with cloning the Errbit repo and copying over the two required config files:

git clone https://github.com/jdpace/errbit.git
cd errbit
cp config/config.example.yml config/config.yml
cp config/mongoid.example.yml config/mongoid.yml

Now, open up config/config.yml, set the host for your app to your (supposed) Heroku url and specify a from-email address:

host: YOUR_APP_NAME.heroku.com
email_from: noreply@example.com

Accordingly, open up config/mongoid.yml to set up the database connection in production to use the MONGOHQ_URL environment variable set by Heroku after adding the MongoHQ addon:

production:
  uri: <%= ENV['MONGOHQ_URL'] %>

Finally, let's add those files to git and commit the new configuration:

git add -f config/config.yml config/mongoid.yml
git commit -m "Heroku configs"

Heroku setup

Of course, you should have the heroku gem installed and set up for this to work.

Still inside your local errbit clone, create the app and add the MongoHQ and Sendgrid addons to get the required MongoDB and mail delivery capabilities, then, deploy Errbit and seed the database:

heroku create YOUR_APP_NAME
heroku addons:add mongohq:free
heroku addons:add sendgrid:free
git push heroku master 
heroku rake db:seed

After seeding the database, you should see a notification holding your initial credentials. You should visit your fresh Errbit install to verify everything works fine and to change the credentials and your user name right away.

Enforcing the use of SSL

As I said before, I'm no fan of exception data delivered over the net unencrypted. Luckily, Heroku offers free SSL on subdomain apps (foo.heroku.com) using their heroku.com wildcard certificate. Enable it by running:

heroku addons:add ssl:piggyback

Now, let's enforce the usage of SSL even when users arrive at the app via plain HTTP instead of HTTPS by installing the middleware Rack SSL Enforcer gem into Errbit.

Open up the Gemfile and add:

gem 'rack-ssl-enforcer', :group => :production

Then, open up config/application.rb and tell Rails to use the middleware:

config.middleware.use Rack::SslEnforcer, :except => /^\/deploys/

The except clause for the deploy API is neccessary since obviously Hoptoad does not report deployments via SSL even when secure connections are configured in the Notifier. You can remove this if you can do without Deployment tracking.

As a final step, update your Bundle, commit and push:

bundle
git commit -am "Rack SSL Enforcer"
git push heroku

Configuring the Notifier in your application

Finally, it's time to wire up your (supposedly ;) existing Rails app with your custom exception tracker.

Go back to the Errbit web interface and add an app. It will give you instructions on how to set things up. Basically, for a Rails 3 application, you need to add gem 'hoptoad_notifier' to your Gemfile, then create config/initializers/errbit.rb.

The configuration suggested by Errbit does not reflect our desired usage of secure SSL connections properly, though, so you'll have to add the config.secure = true option to make things work, as shown below. The port config can be omitted, it will default to 443 when using secure connections.

config/initializers/errbit.rb:

HoptoadNotifier.configure do |config|
   config.api_key = 'ABCDEF'
   config.host    = 'YOUR_APP_NAME.heroku.com'
   config.secure  = true
end

After a final bundle, you should be able to track exceptions using hoptoad_notifier and Errbit. Test-fire it with:

rake hoptoad:test

You can also track deployments via rake, for example from a git hook - check to the documentation of Hoptoad Notifier for further information.

Test fire a deployment notification with:

rake hoptoad:deploy TO=production REVISION=1234 REPOSITORY=origin USER=colszowka

And that's all I can say.

Throw It!

2010-10-22

Photo by raysto

How I'm using Ruby exceptions and Rails' rescue_from to keep controllers clean and error response handling DRY and RESTful.

Quite often in a Rails app we'd do something like this in a controller that needs to fetch a record from database:

class PostsController < ApplicationController
  before_filter :find_post, :except => [:index, :new, :create]
  before_filter :access_permitted?, :except => [:index, :new, :create]
  
  # Actions...
  
  private
  
  # Retrieves the post, redirecting back to index on failure with a custom message
  def find_post
    @post = Post.find(params[:id])
  rescue ActiveRecord::NotFound => err
    flash[:error] = "Could not find post with id #{params[:id]}"
    redirect_to posts_path
  end
  
  # Makes sure the current user is allowed to access this post.
  # Redirect back to index when auth fails
  def access_permitted?
    unless @post.user == current_user
      flash[:message] = "You are not allowed to access this post!"
      redirect_to posts_path
    end
  end
end

In my opinion, this has two problems:

The code is not DRY
The response is not RESTful

Let me explain:

All across your app, you will have similar functionality. You might have a UsersController and a CommentsController, and all of those need to find an instance, authorize the user and so on.

All this functionality needs separate error handling code when going down the path of redirecting the frontend user to another page with custom error messages, which can result in a lot of (mostly) duplicate code, where only the error message and endpoint url vary. When you want to change the error handling for records that could not be found, you have to do it across all your controllers over and over again.

Also, this (simple) example does not cover the handling of other formats than HTML. If you had to deal with, say, JSON requests, you'd also have to introduce respond_to blocks over and over again. Imagine you need some additional auth in a certain action (users may edit a wiki page but are not allowed to destroy it) - even more failure response code is required.

Additionally, this approach is not RESTful: A resource that is missing should not respond with a HTTP redirect, which actually says that either the resource was Moved Permanently (301) to a different or was Found (302) at a temporarily different url (see RFC2616) (the Rails default for redirect_to being 302).

After all handling auth or database retrieval problems is handling of exceptional cases in a Rails app's regular flow, so why not use exceptions?

Rails comes with a built in ActionController class method called rescue_from which, from what I've seen so far, is not as popular or widely used as it should be. Basically it intercepts exceptions at the top level of the request (before the infamous 'There seems to be a problem' 500.html page is rendered) and lets you handle them the way you want.

Let's have a look at how this could be implemented in the ApplicationController for this app.

class ApplicationController < ActionController::Base
  # Just define an example no permission exception for auth. 
  # Might be thrown by authorize before filter on fail.
  class NoPermissionError < StandardError; end;

  rescue_from ApplicationController::NoPermissionError do |e|
    response_for_error 403
  end
  
  rescue_from ActiveRecord::NotFound do |e|
    response_for_error 404
  end
  
  private
  
  def response_for_error(status)
    respond_to do |f|
      # Show a neat html page inside the app's layout for web users
      f.html { render :template => "errors/#{status}", :status => status }

      # Everything else (JSON, XML, YAML, Whatnot) gets a blank page with status
      # which can then be understood and processed by the API client, 
      # JavaScript library (on Ajax) etc.
      f.all { render :nothing => true, :status => status }
    end
  end
end

Of course, the status-specific templates must be added inside the app/views/errors/ directory for the response_for_error method to work properly. This is left for the reader as an excercise ;)

The cleaned up PostsController would look somewhat like this:

class PostsController < ApplicationController
  before_filter :find_post, :except => [:index, :new, :create]
  before_filter :access_permitted?, :except => [:index, :new, :create]
  
  # Actions...
  
  private
  
  def find_post
    @post = Post.find(params[:id])
  end
  
  def access_permitted?
    raise ApplicationController::NoPermissionError unless @post.user == current_user
  end
end

It's certainly not a lot less code in the PostsController when comparing it to the previous version, but actually we've got quite a bit of extra functionality with this:

We are rendering actual error pages with proper HTTP status codes
The handling of all the different http error condition statuses is handled coherently:

Frontend users will see a customized error page inside the app's layout

"Backend" users (JSON, YAML, XML, Ajax) will get a uniform response with an appropriate status code
All across the app, throwing the approprite exception when an error condition occurs bubbles up to the rescue method and will be handled the same way.

For example, your models might have exhaustive permission control. With this kind of error handling, you could throw a NoPermissionError inside of your model and it will bubble up through the controller for the current request and render the appropriate error page - without a need for a single line of exception handling code inside the specific controller that is handling the request.

Considering you will likely remove the same duplicate code from quite a few controllers which your app surely has, you also end up with a fair share of removed lines of code while still getting extra functionality.

Once I've gotten used to bubbling up exceptions and handling them centrally in the ApplicationController, I've also found writing actual controller code a lot easier: It's very comforting to know that any exceptional cases will be handled properly and don't need my further attention apart from throwing the right exception when something goes wrong.

p.s. Of course this approach will fail miserably if you are catching all exceptions in your actions like this:

  def update
    @post.update_attributes!(params[:post])
  rescue => err
    # Do something
  end

You are not doing this, right?

If you cannot handle an exception, you should not catch it because otherwise you will prevent other code that is capable of handling it to work. Actually, as long as you do not raise again, nobody outside will notice that there was an error in the first place.

Thanks for reading, let me know about your approaches!

RedirectFollower Rubygem

2010-04-30

Photo by Shenghung Lin

Today I've been thinking about a small Twitter-based project which involves urls posted by people there. Those urls use some url shortening service like bit.ly in most cases - but I needed the actual destinations for those links. I ended up stealing code from John Nunemaker, wrapping it up into a Ruby gem and releasing version 0.1.0 of RedirectFollower. You can find the source code on GitHub.

Actually, I modified the source code a bit so you don't have to hit "resolve" manually after initializing the RedirectFollower. Also, there's a shorthand form.

After installing with gem install redirect_follower, you can either go the short way if you only want the url of the destination, or initialize a new instance of RedirectFollower to get the Net::HTTP response with status, body and all that malarkey.

require 'redirect_follower'  
RedirectFollower('http://bit.ly/cteFsP') 
# => Will return 'http://github.com/colszowka/redirect_follower'

Full-on mode:

require 'redirect_follower'  
redirect = RedirectFollower.new('http://bit.ly/cteFsP')

# Will print 'http://github.com/colszowka/redirect_follower'
puts redirect.url 

# Will print a lot of HTML
puts redirect.body 

# Returns the Net::HTTPResponse (well actually, a subclass for the respective HTTP 
# status of the destination)
redirect.response

You can limit the amount of redirects by giving a second parameter:

require 'redirect_follower'  
RedirectFollower('http://bit.ly/cteFsP', 2)

This will raise RedirectFollower::TooManyRedirects when there are more than two redirects. The default limit is 5.

Offtopic:

I know I was supposed to write an article about my crazy new ruby blog software serious, that's going to arrive anytime soon. I figured this time I'm gonna write the article about a new Rubygem of mine straight after release so I don't end up not doing it at all. Regarding that serious article, I am planning to do an introductory screencast, but did not get past creating a linux tool that makes typewriter sounds when typing. Hopefully, I'll actually make use of it soon!

Moved my blog

2010-02-25

After finally realizing that it really is Wordpress that is stopping me from writing more frequently because of the additional hassle with formatting, linking and syntax highlighting, I created my own blog software which features Markdown formatting, CodeRay syntax highlighting, and moved my blog over to heroku.

The blog software is called serious and you can find the source on github. I will write more on this and how you can use it soon, but until now let me just apologize for (potentially) introducing a lot of unread items into your feed reader because of modified publishing dates!

Also, the url of my blog has changed to colszowka.heroku.com, but I might feel like updating the olszowka.de domain to point there as well at a later point of time.

I'm totally looking forward to post more frequently here soon, starting with some introductury posts on serious and it's formatting companion, stupid_formatter!

Happy new year!

2010-01-03

It's a bit belated for sure, but I was stuck at my girlfriend's family in southern Germany and in the holidays, so there was no time (or reason) to get in front of a computer... A happy new year to all of you. Of course, the title of this blog had to be updated accordingly to 2010. I'll try and keep more posts pouring in this year!

Moving Repos and Redmine from SVN to Git

2009-09-11

Sorry for not posting in a long time (again), but I've been pretty busy with summer vacations, work, of course, The Ruby Toolbox and did not have any time to work on some OSS stuff.

What I did do, though, was to migrate two of our major app repositories from Subversion to Git together with my fellow colleague at Capita Unternehmensberatung, Sebastian, who despite being very jealous of my fancy new HTC Hero being so much cooler than his grumpy old T-Mobile G1, joined me on this one :)

Our main goals were to retain our Release Tags from SVN as Git Tags (not Branches!), which worked out perfectly after working through a couple of online resources on this topic, as well as updating our Redmine issue comments and time entries that included references to specific commits to reflect the changes in revision numbering.

For migrating the repositories, I've put together the required steps based upon this, this, and this into a gist, which you can work through manually and should end up with a sweet git repo. Only thing remaining is to set up a bare repository on your scm-server (git init --bare) and push everything over there (at least as long as you sticked to the default SVN repository structure of /tags, /branches and /trunk - everything else you'll probably have to mess around with the listed commands).

For moving Redmine, we created a simple Ruby script which will work through all your git commit messages, create a hash out of the included svn revision id's (from the initial migration), connect to your Redmine database and update everything properly. It's also a gist. Remember you'll have to do this on your Redmine server.

Further instructions and comments are also included inside the two gists, so check them out:

Happy migrating!

Latest updates in The Ruby Toolbox

2009-06-25

Note: This is a cross-posting from the new Ruby Toolbox blog. I won't do these in the future. For all updates on The Ruby Toolbox, please subscribe to the news feed there!

Finally, here is the news post promised almost two weeks ago. In the last two weeks, a couple of updates have found their way to The Ruby Toolbox. Apart from various updates to the layout and other minor improvements, there are three major feature additions, which I will cover in a little more detail.

Projects and Categories listings

In the top navigation bar, you will now find links to listings for categories and projects. They also have some rather nice tooltips, so try and hover them :)

The super-ugly dropdown cateogry selector in the upper right has also been replaced by a fancier navigation which hopefully also addresses the increasing navigation issues that grew out of the old select tag with the boatload of categories that have been added since the Toolbox launched.

Project news

Thanks to the Technorati API, each project now has a listing of blog posts featuring information about it.

The search is done based upon links to the project’s Github repository, so all you people out there writing about something Ruby that is hosted on Github and featured here, please remember to link up the project repo from within your post!

Assuming your blog is being indexed by Technorati, your post should appear on the corresponding project’s category listing. Please let me know if there are issues with that!

The inclusion of project news from the blogosphere leads us straight to the next big addition:

Feeds

Plenty of people have been asking for them, and yes, they finally have arrived!

Apart from the obvious feed for this latest news blog, there are also feeds for recently added categories, recently added projects and, last but not least, a feed for the aforementioned blogosphere index, which will give you the latest blogposts about projects covered in The Ruby Toolbox.

I hope you will enjoy the new features. Please let me know what you would like to see in The Ruby Toolbox and of course you’re free to report any issues and projects currently missing!

Announcing: The Ruby Toolbox

2009-05-01

So, after my return from Cairo and right before heading to Las Vegas for RailsConf tomorrow morning, I have put together a little website called The Ruby Toolbox.

The page is meant to give you information on what Ruby tool from GitHub you could use to do X, Y or Z. The tools are assorted in categories like "Testing Frameworks", "State Machines", "Markup Processors" and so on. The projects listed in each category have scores calculated from their respective GitHub repositories' watcher and fork counts, so you can get an idea which project is the most popular in the dev community.

I hope this will be of use to people i.e. wondering which test framework they should choose from the plethora of options or to find out about alternatives to currently used tools and their popularity.

So, head over to ruby-toolbox.com and drop me a line whether you like it, tweet me @thedeadserious or tell me right at RailsConf in Vegas!

If you want a (your?) project or another category added, please also drop me a line because the categories and projects on the page only serve as a starting point. This will hopefully grow in time!

Burn like fire in Cairo

2009-04-13

Sorry for not posting a lot in the last weeks, I've been really busy and today I'm leaving for my well-deserved holidays in Egypt, joining my girl and friends who have been there for a couple of weeks already. When I'm back I'll be in Hamburg for one week and hopefully able to finally write about my XMPP-Bot called MessageMate.rb. In the meantime, you are of course allowed to check it out on your own, the Readme provided on GitHub should provide you with some directions. Saturday, May 2nd then, I'm departing for RailsConf 09, which hopefully will be a blast like the last two RailsConfs in Portland, which I thankfully was able to attend. I'm not looking forward to Vegas as a city though, Portland was really impressive and I hope that I can get back there some day :)

Ruby, Rails, RHTML and Shoulda Snippets for gedit

2009-04-10

Gedit is the built-in text editor of Gnome. It is really straight-forward and no-bs, so it is my favorite environment for coding, since I prefer things to be really snappy rather than standing in my way.

It has a built-in snippets plugin which allows for easy expanding of your predefined shortcuts into the actual method name by hitting TAB - very much like TextMate or plenty of other editors that have such a feature. The snippets for Ruby supplied by default are pretty sloppy and incomplete though, so I've built my own.

They feature not only the default Ruby def, class, if (...) statements, vastly improved compared to the original ones supplied with gedit, but also ActiveRecord validations, associations, ActionController before filters, ERB, and Shoulda macros. For example, sstft will expand to should_set_the_flash_to :(cursor_position).

Please check the command cheatsheet on the corresponding github page and have a look at the documentation in the Readme supplied in the Github repository for instructions on how to install them, which basically are two shell commands

If you need to set up mime-types and syntax highlighting for Ruby and friends, please also check out these two articles, which are a tad dated but still should lead to a working setup for your coding galore:

In the Readme on Github, I also supplied a couple of rules that I am trying to stick to when writing new snippets. Feel free to fork the repository, add Snippets and send me a pull request! And to make things even fancier, here is a sweet little video demonstration of some of the snippets:

Another state machine for Ruby

2009-03-09

Aaron Pfeifer from PluginAWeek has released a pretty decent state machine today. It's got plenty of neat features like before- and after-transition hooks, state machine namespacing and the ability to add multiple state machines to a single class, integration with ActiveRecord, DataMapper and Sequel, the possibility to add validations to your model in certain states and, last but not least, an automated GraphViz visualization generator, which will give you a nice little drawing of your state machine.

I will definetely check this out next time I need a state machine.

Introducing ActiveRecord Skeleton

2009-02-21

It's common knowledge that ActiveRecord can be used nicely without Rails in Ruby apps. Setting up the basic stuff is pretty easy by just requiring the activerecord gem in your app and defining a couple of models.

But what about migrations, yaml config and different environments? You have to set all this up manually, and even though this is not really hard, it's still a time-consuming task. No more!

Enter: ActiveRecord Skeleton

I published a new project on GitHub today, called ActiveRecord Skeleton, and it really is just that: It will instantly give you YAML db config, database migrations (including Rake tasks for migrating the database as well as generating new migrations), a Rails-style project directory structure, and also the option of using environments by specifying the RACK_ENV environment variable. Why RACK_ENV? Well, you might also see this as a super-minimalist web app template, allowing you to set up a db-backed Sinatra (just an example, anything should work really) app instantly. All you really got to do is get the skeleton and add an application.rb file containing the following:

require 'sinatra'
require 'init'

get '/' do
  User.all.map {|u| u.name}.to_sentence
end

After running application.rb and pointing your browser to localhost:4567, you will see the list of existing users (assuming you've got the database and model set up properly, of course).

Want to create a user? Start irb, do a require 'init' followed by User.create.

This skeleton is really minimalist, as I didn't want it to be over-opinionated. It's meant to give an easy start for about any Ruby code you might want to have database-interaction with and is ready to go with sqlite 3 in the default setup, but you really can use it with any database ActiveRecord supports.

As a consequence of the minimalist approach, the skeleton does not supply tasks or folders for tests. The reason for this is simply that I did not want to force users of the skeleton into using a certain testing library. Test::Unit, Shoulda, RSpec, (your favorite testing framework mentioned here), just pick your favorite and add it your project. This is by no means a suggestion to ditch testing altogether though. You're just supposed to pick your flavour of TDD or BDD.

Now head over to GitHub and give it a spin!

Giraffesoft releasing Gems and Plugins this week

2009-02-17

The folks at Giraffesoft have decided to release some of the common code they've been using in their projects into plugins and gems on their brand-new company blog. In their own words:

At giraffesoft, we're big believers in extracting functionality sooner rather than later. This practice has resulted in a ton of code that we use in all of our projects — nice and DRY. Only problem is, we never get around to releasing this stuff. Starting a blog seemed like a good excuse to spend some time polishing up some code and, you know, writing READMEs. So, starting today, we'll be releasing an open source project every day this week. They'll probably be mostly rails plugins. But, you never know. Something else might float in.

Actually, something else did float in right on the first day: Classy Resources for Sinatra, a gem allowing you to create restful web services that can be consumed by ActiveResource without manually defining all of the controller actions, but rather with a (very Railsish) configuration-style method:

define_resource :posts, :member => [:get, :put, :delete], :collection => [:get, :post], :formats => [:xml, :json, :yaml]

The thing is pretty customizable and even if it's not exactly what you need, it still might be interesting to investigate the source code to see how to refactor common code into modules in Sinatra.

If you don't know Sinatra yet, you really should go and check it out at Github and have a look at the Sinatra book.

RDoc index for your Gems

2009-02-13

I just posted a tiny script on gist.github.com I wrote recently for usage on my dev machine that will create a HTML index for your locally installed RubyGems because I got really tired of having to browse through extraordinarily long paths to get to that local RDoc for ActiveRecord 2.0.2.

Just generate the index with the script, bookmark the index.html file in the output directory and get immediate access to your local RDocs. You might also want to put the script into a cron job for automatic updating.

Here's a screenshot of the index in action on my machine:

The code is certainly not beautiful or anything, but it works for me and hopefully for you too!

Get the thing here: Local RDoc Index Generator

Added my Google Reader Shared Items

2009-02-09

Just a quick update since I am really busy learning for my exams: I added a RSS widget to the sidebar, featuring the postings I marked as "shared" in Google Reader.

Google Reader is really great for keeping up with the latest news and sharing them with others. The most stuff I mark as shared is Rails-related stuff anyway, so I thought it'd be a good idea to just add the feed here as well :)

Update: Turns out the Wordpress RSS Widget is not compatible with the Google Reader Shared Items Atom feed, mangling the urls and titles while processing. I found out how to fix that using Feedburner though, so now everything should work.

Rails 2.3 release candidate out

2009-02-02

The first release candidate of Rails 2.3 is out, which will probably be the last one in the 2.X-branch with the preview release of Rails/Merb 3.0 being scheduled for RailsConf in May 2009. Install with

gem install rails --source http://gems.rubyonrails.com

There is plenty of great, new features in Rails 2.3, so be sure to check out the official release notes as well as Ryan Daigles article featuring links to all of the summaries he wrote about the new features in the past months.

Ruby / Rails related links

2009-01-24

Sinatra app template

Nick Plante has released a nice application template for Sinatra, with a reasonable initial directory structure and a Rackup script for easy use with Passenger. Haml, DataMapper, RSpec and such are also included, so this is pretty biased, but you’re free to fork it and adjust to your needs on github

I gave it a spin and had no problem to run it with Passenger by just pointing the Apache vhost configuration to the public folder of the app, so this is also great when you’d like to have an example on using Rack apps with Passenger.

Rails templates

Application templates seem to be up and coming currently, with the best thing obviously being the Rails templates feature in Edge Rails a.k.a. the upcoming Rails 2.3. Core member Pratik Naik posted a nice summary of the available methods in December, and Peter Cooper from Rails Inside posted more on the topic yesterday, with links to example scripts.

Basically this allows for scripting of the Rails application generator, giving you a DSL with methods to pull in plugins, executing rake tasks and so on. The template can be pulled in remotely, for example from a gist. Peter “Super Daring App Template” can be used with rails [whatever] -m http://gist.github.com/33337.txt, and you are free to fork it and roll your own.

Some kind of template database would be nice though, listing all public templates and their features, so you can pick your favorite and use it.

Zebra – One line tests for shoulda, context and matchy

I really like Shoulda. James Golick has released a gem that enhances it further, called Zebra.

The functionality can be summed up with this example from James’ initial post:

should "be editable by its author" do
  assert @post.editable_by?(@author)
end

becomes…

expect { @post.to be_editable_by(@author) }

Roll your own Pastebin with NavySnip

NavySnip is a pastie pastebin Rails application, but intended for localhost use. Check out the screenshot or have a look at the github repository.

Currently, it does not have syntax highlighting, but with a little help from Coderay or a similar Ruby gem, it should be easy to bring that into the app.

Free Lighthouse/Basecamp-inspired web app theme

Andrea Franz released a nice-looking web app theme that looks very familiar if you have been to sites like Lighthouse or Basecamp. Go check it out at Github and make a great app with it!

Little Known Ways to Ruby Mastery by Ryan Bates

To finish things up, there is a nice interview with Ryan Bates over at Rubylearning

RailsConf Europe 2009 cancelled, registration for Vegas open

2009-01-24

As David A. Black states on his blog, there won't be a RailsConf Europe this year:

Ruby Central and O’Reilly have decided to take a hiatus from producing RailsConf Europe this year, for the simple reason that it didn’t bring in enough revenue last year to justify doing it again, particularly given the tight economy and the need to err on the side of caution. RailsConf Europe has always been a really great event, and people who go to it really love it, but we need a year of retrenchment while we figure out how to get everyone else to realize how great it is! Plans for 2010 are not certain yet; we’re taking it one year at a time.

Quite disappointing, even though I was not in Berlin last year (but oddly enough in Portland, which makes for a travel distance of several thousand kilometers against 300). Maybe they should not have the conference hosted in super-exclusive downtown-hotels (like it was at the Maritim in Berlin), but rather just in some convention center.

In other news, David Heinemeier Hansson has announced the opening of registration for RailsConf 2009 in Las Vegas. The event is taking place from May 4th through 7th, in the Las Vegas Hilton. I really hope this does not mean RailsConf US won't be happening in 2010 for not "bringing enough revenue", as I can imagine the Las Vegas Hilton being more expensive to rent than the Oregon Convention Center in the last years.

They have early registration open until March 16th, so go and grab a seat and save 200 bucks!

You might also want to check out this years CabooseConf, the Ruby/Rails hacker event which will also be taking place at the Las Vegas Hilton during RailsConf, and can be entered for free with an exhibit hall only pass. You might be asked for a link to an open source submission you did, though.

Setting up the whole Rails stack from a single Debian meta package in 10 minutes

2009-01-22

After staying almost the whole last week in the hospital because all of a sudden my appendix decided to hurt and part ways with me, I finally managed to finish my article I announced earlier on installing a whole Rails stack with Apache2, MySQL, Ruby, Rubygems, Phusion Passenger from a single Debian package file using the DebGem service and the Brightbox Passenger Debian packages.

This article won’t cover many basics of using the DebGem service. If you need an introduction, you might want to check out my earlier postings on the topic.

Preparing the VM

Just like in my second post on DebGem, I used a vanilla Ubuntu JeOS 8.04.1 LTS install in Virtualbox. Apart from the openssh-server package for easier access to the machine and an initial sudo apt-get update && sudo apt-get upgrade, the machine was untouched.

To start out, I installed the most basic required cli tools with

sudo apt-get install bash-completion nano wget curl

since JeOS is so much “Just enough OS” it does not even supply these very common packages. After this, the machine is ready to install the stack.

Adding the DebGem and Brightbox repositories

The additional debian repositories needed to be added to the apt package sources now in order for the Gems and Passenger to be installed properly:

# Switch to root shell
sudo -s 

# Add debgem repository
sh -c 'echo "deb http://www.debgem.com/apt ubuntu-8.04 rubyforge" > /etc/apt/sources.list.d/debgem.list'
sh -c 'wget -q http://www.debgem.com/apt/debgem.gpg -O- | apt-key add -'
sh -c 'echo "APT::Cache-Limit 33554432;" > /etc/apt/apt.conf'

# Add brightbox passenger repository
sh -c 'echo "deb http://apt.brightbox.net hardy main" > /etc/apt/sources.list.d/brightbox.list'
sh -c 'wget -q -O - http://apt.brightbox.net/release.asc | apt-key add -'

# Update repository index
apt-get update

Installing the stack from the deb file

I uploaded the sample .deb file and it’s sources to github. The tarball of the project can be retrieved and extracted with:

wget -nv http://github.com/colszowka/railsstack.deb/tarball/master -O- | tar xzv -C /

Now just switch over to the extracted folder’s subdirectory ‘deb’:



  cd colszowka-railsstack.deb-8bfcf1812c76766c095eb5a1510f2e84742b703a/deb/

The installation of the whole stack can now be invoked with



dpkg -i --force-depends railsstack.deb

Unfortunately, the dpkg command is unable to resolve remote dependencies, so the output will print a multitude of unresolved ones. But worry not, these will get automatically resolved by apt-get when running the following command:

apt-get -f install

The whole install will kick off now, installing as much as ruby, ri, rdoc, irb, rubygems, apache2, mysql-server-5.0, mysql-client-5.0, rails2.2.2-ruby1.8, libfastthread-ruby1.8, libapache2-mod-passenger and libmysql-ruby completely automatically. You will get asked for your desired MySQL root user password once, but that’s about it. After a couple of minutes, everything should be ready for the big test. Do not forget though to exit the root shell when installing Typo!

Test run with Typo 5.1.98

To check if Apache2/Passenger, MySQL, Ruby, Rails and everything else worked fine, I gave it a spin with the Typo Rails open source blog app:

cd ~
wget http://rubyforge.org/frs/download.php/49562/typo-5.1.98.tgz
tar xfz typo-5.1.98.tgz
cd typo-5.1.98
cp config/database.yml.example config/database.yml
nano config/database.yml # Enter db credentials...

As a next step, the databases needed to be setup and the hideous .htaccess file from Typo’s public folder must be removed due to the problems it causes in combination with Apache.

rake db:create:all
rake db:migrate RAILS_ENV=production
rm public/.htaccess

To finish things, I just removed the default Apache2 host and defined my own for the Typo app using Passenger:

sudo rm /etc/apache2/sites-enabled/000-default 
sudo nano /etc/apache2/sites-enabled/passenger

The config looks like this:


    ServerName 127.0.0.1
    DocumentRoot /home/colszowka/typo-5.1.98/public

Just a restart of Apache missing, sudo /etc/init.d/apache2 restart, and everything’s done, done! Let’s verify everything works:

$ curl localhost
You are being redirected.

Sweet! To have a look at the site with my web browser, I created a port forwarding in VirtualBox (I wrote on how to accomplish that earlier) and pointed my browser to localhost:3123, the port I chose for the forwarding. The result in pictures rather than words:

The structure of the .deb package

The Debian (meta-)package used to setup the whole Apache/Passenger/MySQL/Ruby/Rails stack in merely ten minutes is pretty straight forward. It only consists of a control file sitting inside a DEBIAN folder. The file only describes the packages it depends upon, which then will be pulled in by apt-get. Take a look at it over at github

The control file looks like following:



Package: railsstack

Essential: no

Priority: extra

Section: metapackages

Maintainer: Christoph Olszowka 

Architecture: i386

Version: 1

Depends: ruby, ri, rdoc, irb, rubygems, apache2, mysql-server-5.0, mysql-client-5.0, rails2.2.2-ruby1.8, libfastthread-ruby1.8, libapache2-mod-passenger, libmysql-ruby

Description: Metapackage for installing a Ruby on Rails stack on Apache2 with MySQL using Passenger (built by Brightbox) and DebGem.com

Note: Unfortunately and as mentioned before, this will currently still pull in loads of Rails versions and it’s dependencies since obviously the DebGem gem dependency list is still not working properly (or it is intendend to work like this, which to me makes no sense when I pull in a specific version of Rails, like I did in the control file with depending upon rails2.2.2-ruby1.8)

Building the package is simple: dpkg -b package railsstack.deb. After that, just put the .deb file on your server and execute mentioned commands:

dpkg -i --force-depends railsstack.deb
apt-get -f install

Conclusion

Providing .deb metapackages allows for really simple, quick and straight-forward deployment of any Rails app on a vanilla Ubuntu JeOS Server. Rubygems even get updated automatically by DebGem to the latest version, so I did not have to stick with the old default Ubuntu package of Rubygems.

I did not try this yet with the actual Ubuntu Server distribution, which is much more widely used on servers, but since the server edition depends upon the same basic packages (apache2, mysql-server-5.0) as JeOS does, things should work the same way, maybe even quicker if you install the basic packages like Apache and MySQL from the CD.

Update, 2009-01-12: I actually tried this process on a new install of Ubuntu Server 8.04 with preinstalled LAMP, and everything worked just perfectly with the same steps as described above. The package manager recognized the already installed MySQL and Apache packages and did not try to reinstall them, just pulling in Passenger, Ruby and Rails.

Similar packages for Sinatra, Merb or anything you might want up and running quickly on your server should be no problem at well with a customized Railsstack.deb, so with a little help from DebGem and Brightbox, setting up a working Ruby environment for almost any Ruby server application becomes a no-brainer.

With the steps mentioned above, I was able to go from a freshly installed Ubuntu JeOS 8.04.1 to accessing the Typo site hosted on the machine in just 10 minutes, and plenty of this time was spent with downloading old Rails versions from DebGem, which hopefully will get sorted while the service is still in beta. When it becomes possible to pull in just the required versions of gems, it might be possible to have Typo running in just 5 minutes.

DebGem test-run on a vanilla Ubuntu

2009-01-09

Like already announced in my previous first look into the new DebGem service by Phusion. I had a deeper look into the service today, giving it a spin under a freshly installed Ubuntu Server JeOS virtual machine.

JeOS is great since it has a kernel tweaked for virtual environments and the disc image has a footprint of only 100 megs, which ensures download and install times are low.

Setting up the vm for testing

Since DebGem currently only offers binary packages for Ubuntu 8.04 LTS, I picked up the JeOS cd image for that, which can be downloaded in the latest version 8.04.1 from here.

After setting up a new Ubuntu-based virtual machine VirtualBox and getting through the installation steps for Ubuntu JeOS (I won’t get into detail about that…), as a first step I updated the whole system with apt by issuing:

sudo apt-get update && sudo apt-get upgrade

This was followed by the install of the most basic tools:

sudo apt-get install bash-completion nano wget curl man

I also installed openssh-server so I could access the machine from my regular terminal, but that is optional. If you decided to follow along, please remember that you will have to set port forwarding for VirtualBox properly. On the machine you are running VirtualBox on, first find the name of your VM by typing:

VBoxManage list vms

Find your new virtual machine and remember it’s name. Now you will have to set the port forwarding for ssh with the following commands, putting your vm’s name in the obvious spot:

VBoxManage setextradata "YOUR VMS NAME" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/ssh/GuestPort" 22
VBoxManage setextradata "YOUR VMS NAME" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/ssh/HostPort" 2222
VBoxManage setextradata "YOUR VMS NAME" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/ssh/Protocol" TCP

You can double-check if everything worked out by issuing,

VBoxManage getextradata "YOUR VMS NAME" enumerate

which should give you a list of your machines properties, including the newly set forwarding options. Now you will have to completely shut down and start up your vm so these options get applied. After that, you should be able to ssh to the machine with:

ssh localhost -p 2222

Setting up Ruby and MySQL

Just install everything from the packages by issuing

sudo apt-get install ruby ri rdoc irb rubygems mysql-server-5.0 mysql-client-5.0

MySQL will ask you for a new password for the root user, type it in and you’re ready.

Adding the DebGem apt repository

To add the Rubyforge gems to apt, issue the following commands:

sudo sh -c 'echo "deb http://www.debgem.com/apt ubuntu-8.04 rubyforge" > /etc/apt/sources.list.d/debgem.list'
sudo sh -c 'wget -q http://www.debgem.com/apt/debgem.gpg -O- | apt-key add -'
sudo sh -c 'echo "APT::Cache-Limit 33554432;" > /etc/apt/apt.conf'
sudo apt-get update

This will add the debgem repository, add their key so apt-get won’t complain and also raise the cache-limit, which is required due to the amount of packages served by DebGem. Finally, we update the whole cache so the Gems will appear in apt-get.

Please remember the following though, taken from the DebGem usage page:

Note: These URLs will likely change after DebGem has gone out of beta, so please check this web page again if apt-get update doesn’t work anymore.

Testing DebGem, part 1: Hpricot

I chose Hpricot because its basic functionality can be tested in a single line with irb, while it still is a native extension which normally would have required me to install at least the build-essential Ubuntu package, if not some required libraries as well which I would have to hunt down in the Ubuntu repositories. Installing Hpricot via DebGem on the other hand is pretty straight-forward:

apt-get install libhpricot-ruby1.8

After that and opposing to my findings in my previous post, when I was not able to install any gems from DebGem due to my manual install of RubyGems, the Hpricot gem now appeared in my gem list:

gem list --local
*** LOCAL GEMS ***
hpricot (0.6.164, 0.5, 0.4)

Now, let’s see if it works!

$ irb1.8 
irb(main):001:0> require 'rubygems'
=> true
irb(main):002:0> require 'hpricot'
=> true
irb(main):006:0> Hpricot('bar').at("#foo").inner_html
=> "bar"

Sweet! On a vanilla Ubuntu JeOS system, I was able to set up a working Ruby install including Rubygems in no time and without the need to search for build dependencies. DebGem even auto-updated my Rubygems when I downloaded Hpricot, which normally is the probably most ugly thing about the Ubuntu Rubygems package:

$ gem --version
1.3.1

Testing DebGem, part 2: DataMapper

DataMapper is a native extension as well, featuring plenty of dependencies and database access. On my initial review of DebGem, apt-get wanted me to pull in plenty of old versions as dependencies even when trying to install a specific version of DataMapper. Since then, the latest version of DataMapper, 0.9.9, has found it’s way into the repository. Also, Hongli Lai from the Phusion team posted a comment to mentioned article, saying that the DebGem team had removed most of the unneccessary dependencies.

When trying to install libdatamapper0.9.9-ruby1.8 today, DebGem still wanted me to pull in plenty of packages, but this time only the most recent versions, the reason for all the bulk print on my screen being the usage of metapackages. There still seems to be an issue with the projected package disc space usage though, which Hongli Lai also pointed out, since the announced 22.2 mb did not end up on my hard disc. The full install of Datamapper 0.9.9 weighs 10 mb on my hard disc.

Since I wanted to use MySQL, I also had to install the do-mysql gem:

sudo apt-get install libdo-mysql0.9.10.1-ruby1.8

As a next step, I set up a testing database through mysql console:

$ mysql -u root -p 
mysql> create database datamapper_test;
Query OK, 1 row affected (0.00 sec)

I created a simple DataMapper example, which was the following:

require 'rubygems'
require 'dm-core'

DataMapper.setup(:default, 'mysql://root:pass@localhost/datamapper_test')

class Message
  include DataMapper::Resource
  property :id,         Serial 
  property :body,       String
end

DataMapper.auto_migrate!

Message.create(:body => "I'm a Message")

puts Message.all.inspect

Executing the whole thing went perfectly right, with Datamapper obviously connecting to the database, migrating the table, creating the message and retrieving all messages afterwards. The console output was, just as expected:

[<Message id=1 body="I'm a Message">]

Again, that wasn’t hard at all.

Testing DebGem, part 3: Rails

As a final test, I wanted to see if I could get a Rails app to run with gems installed from DebGem. Currently, when installing a specific version of Rails, say rails2.2.2-ruby1.8, all the dependencies like ActiveRecord, ActionPack and so on will be pulled in all versions available via DebGem – exactly the same way as it was in my earlier review for DataMapper. The result was a vm crammed with:

actionmailer (2.2.2, 2.2.1, 2.2.0, 2.1.2, 2.1.1, 2.1.0, 2.0.5, 2.0.4, 2.0.2, 2.0.1, 2.0.0, 1.3.6, 1.2.5, 1.1.5, 1.0.1)
actionpack (2.2.2, 2.2.1, 2.2.0, 2.1.2, 2.1.1, 2.1.0, 2.0.5, 2.0.4, 2.0.2, 2.0.1, 2.0.0, 1.13.6, 1.12.5, 1.11.2, 1.10.2, 1.9.1, 1.8.1, 1.7.0, 1.6.0, 1.5.1, 1.4.0, 1.3.1, 1.2.0, 1.1.0, 1.0.1)
activerecord (2.2.2, 2.2.1, 2.2.0, 2.1.2, 2.1.1, 2.1.0, 2.0.5, 2.0.4, 2.0.2, 2.0.1, 2.0.0, 1.15.6, 1.14.4, 1.13.2, 1.12.2, 1.11.1, 1.10.1, 1.9.1, 1.8.0, 1.7.0, 1.6.0, 1.5.1, 1.4.0, 1.3.0, 1.2.0, 1.1.0, 1.0.0)
activeresource (2.2.2, 2.2.1, 2.2.0, 2.1.2, 2.1.1, 2.1.0, 2.0.5, 2.0.4, 2.0.2, 2.0.1)
activesupport (2.2.2, 2.2.1, 2.2.0, 2.1.2, 2.1.1, 2.1.0, 2.0.5, 2.0.4, 2.0.2, 2.0.1, 2.0.0, 1.4.4, 1.3.1, 1.2.5, 1.1.1, 1.0.4, 1.0.1)

This is only the result of issuing sudo apt-get install rails2.2.2-ruby1.8! Obviously the package dependencies need some fine-tuning, but I think that is absolutely ok for a service that just came out into beta.

Since I needed an app to test Rails with, I wanted to create a new one with the rails command. That did not work since the corresponding script could not be found on my operating system. Maybe this can be fixed with a modified path though. I didn’t bother and pulled a sample app from my main machine. After generating the controller “debgem”, which worked flawlessly, I added an index action to the newly created controller:

# app/controllers/debgem_controller.rb 
class DebgemController < ApplicationController
  def index
    render :text => "Hello from Debgem"
  end
end

A ruby script/server later, I was able to curl my action:

$ curl localhost:3000/debgem
Hello from Debgem

Great success!

Conclusion

To summarize all this, I still think that DebGem is a very promising service with some rough ends which will hopefully get sorted out while in beta. The folks at Phusion seem as they really want to make this work like a charm, taking care of the issues mentioned by users. I’m sure they will take care of the remaining issues and make this even more kick-ass. If you are having issues with DebGem, be sure to check out the DebGem Google Group.

The service makes it really easy to setup a whole Ruby environment on a Ubuntu / Debian machine quickly and without much fuzz. No need to build anything (on Ubuntu 8.04, for now), no build-dependencies to pull in before issuing gem install foo. That makes setting up a Rails environment a no-brainer.

In the upcoming follow-up to this article, I’ll focus on setting up a complete Rails stack with Apache2/Passenger from a single .deb Metapackage, so if you’re interested in that check back soon or subscribe to my RSS feed.

So finally, after years of laziness, I managed to set up a blog!

2009-01-06

The plan is to track stuff I stumbled upon on the net, especially interesting blog posts on everything Ruby, Rails and Linux (with a major focus on Ubuntu since this is the distro I am using). Additionally, I might also post some code-snippets I found useful, reviews of books I read and, last but not least, this shall be the final instance to force me into publishing the plethora of tools and apps I developed for my own needs into open source (on github, of course).

Oh and btw, though this is a blog focusing on Ruby and Rails, I am using Wordpress since it gets the job done just perfectly, and while getting the job done more easily has been the reason for most Ruby enthusiasts to switch over from PHP/Java/whatever, in my opinion the choice of the right tools should also imply PHP-productions...

Anyway, I am sending a warm welcome to all you folks out there, I hope that you will enjoy the stuff that will appear here soon!

Phusion releases DebGem.com into beta

2009-01-06

Right after starting this blog, I already have the first topic to post about that implies both things I'm focusing on - Ruby and Ubuntu: As Peter Cooper announced on Ruby Inside, Phusion (of Passenger fame) have released a new service called DebGem. What this thing basically does is let you install all RubyForge and Github gems on Debian / Ubuntu machines via apt-get, which many people (me included) prefer over the duplicate handling which the original gem command requires, while still having access to latest as well as older versions (as opposed to the official repositories, which only hold outdated libs), plus it will install required lib dependencies for native builds, say imagemagick for rmagick. They also have a search set up so you can easily find the exact package name you have to type in when installing.

As Peter states though, there are two "catches":

Native gems requiring a build are currently only available for Ubuntu 8.04 LTS (you might also want to check out the info on supported distros over at their starting page)
The service is only free during beta. Phusions clear explanation to that can be found in the FAQ

Thankfully, I'm still on Ubuntu 8.04 on my laptop, so I was able to try it out. After getting through the config steps (basically just another repository in /etc/apt/sources.list with the catch that you have to raise apt's cache limit due to the huge amount of packages in the repo - Rubyforge without github already gives about 25000 packages) and doing an apt-get update, I was able to get nice datamapper auto-complete results:

colszowka@colszowka-laptop:$ sudo apt-get install libdatamapper
libdatamapper0.1.1-ruby1.8  libdatamapper0.3.2-ruby1.8  libdatamapper-all-ruby1.8   libdatamapper-ruby1.8       
libdatamapper0.2.5-ruby1.8  libdatamapper0.9.8-ruby1.8  libdatamapper-ruby

The naming and version availablity scheme is explained in the FAQ as well. I won't copy and paste all of it, but basically when you install libdatamapper-ruby1.8, it will install all versions listed above.

This is because RubyGems supports parallel version installs. For example, RubyGems allows having both Rails 2.1.2 and 2.2.2 installed at the same time. Applications and libraries can depend on a specific version of a gem. Dpkg does not have a direct equivalent of this feature. So as a compromise, and in order to ensure that everything works out-of-the-box, we install latest versions of the minor version.

Unfortunately, even when I specified a certain version, say libdatamapper0.9.8-ruby1.8, to be installed, the gem dependencies would not get resolved properly, with DebGem requiring me to install a plethora of versions of the gems datamapper depends upon:

  dm-cli-all-ruby1.8 dm-cli-ruby1.8 dm-cli0.9.8-ruby1.8 hoe-all-ruby1.8 hoe-ruby1.8 hoe1.0.5-ruby1.8 hoe1.1.7-ruby1.8 hoe1.2.2-ruby1.8 hoe1.3.0-ruby1.8 hoe1.4.0-ruby1.8
  hoe1.5.3-ruby1.8 hoe1.6.0-ruby1.8 hoe1.7.0-ruby1.8 hoe1.8.2-ruby1.8 launchy-all-ruby1.8 launchy-ruby1.8 launchy0.1.2-ruby1.8 launchy0.2.1-ruby1.8 launchy0.3.2-ruby1.8
  libaddressable-all-ruby1.8 libaddressable-ruby1.8 libaddressable0.1.2-ruby1.8 libaddressable1.0.4-ruby1.8 libaddressable2.0.1-ruby1.8 libdata-objects-all-ruby1.8
  libdata-objects-ruby1.8 libdata-objects0.2.0-ruby1.8 libdata-objects0.9.9-ruby1.8 libdatamapper0.9.8-ruby1.8 libdm-aggregates-all-ruby1.8 libdm-aggregates-ruby1.8
  libdm-aggregates0.9.8-ruby1.8 libdm-core-all-ruby1.8 libdm-core-ruby1.8 libdm-core0.9.8-ruby1.8 libdm-is-tree-all-ruby1.8 libdm-is-tree-ruby1.8 libdm-is-tree0.9.8-ruby1.8
  libdm-migrations-all-ruby1.8 libdm-migrations-ruby1.8 libdm-migrations0.9.8-ruby1.8 libdm-observer-all-ruby1.8 libdm-observer-ruby1.8 libdm-observer0.9.8-ruby1.8
  libdm-serializer-all-ruby1.8 libdm-serializer-ruby1.8 libdm-serializer0.9.8-ruby1.8 libdm-timestamps-all-ruby1.8 libdm-timestamps-ruby1.8 libdm-timestamps0.9.8-ruby1.8
  libdm-types-all-ruby1.8 libdm-types-ruby1.8 libdm-types0.9.8-ruby1.8 libdm-validations-all-ruby1.8 libdm-validations-ruby1.8 libdm-validations0.9.8-ruby1.8
  libextlib-all-ruby1.8 libextlib-ruby1.8 libextlib0.9.9-ruby1.8 rake-all-ruby1.8 rake-ruby1.8 rake0.8.3-ruby1.8 rspec-all-ruby1.8 rspec-ruby1.8 rspec0.9.4-ruby1.8
  rspec1.0.8-ruby1.8 rspec1.1.11-ruby1.8 rubyforge-all-ruby1.8 rubyforge-ruby1.8 rubyforge0.4.5-ruby1.8 rubyforge1.0.1-ruby1.8

The estimated additional disk usage for libdatamapper0.9.8-ruby1.8 from DebGem was noted as 28.1 MB. Quite a bit, but I can only recommend not to try this out with apt-get install rails (which oddly enough does not fall into the libXYZ-ruby1.8 scheme) - 484 MB!

Though installation went well, unfortunately I was unable to access the newly installed gem, even though it should have registered with my current rubygems installation:

All DebGem packages register themselves as Ruby gems, thereby providing full compatibility with Ruby software that expect gems.

colszowka@colszowka-laptop:~$ gem list --local | grep 'datamapper'
colszowka@colszowka-laptop:~$ irb
irb(main):001:0> require 'rubygems'
=> true
irb(main):002:0> require 'dm-core'
LoadError: no such file to load -- dm-core

Obviously the reason for this is that I do have a manual Rubygems install, rather than the one from the (way outdated) Ubuntu repositories. Since I did not want to mess up my whole gems install, I decided to not go further and rather check this out in a virtual machine on a fresh install as soon as possible, so until then I can only tell that the installed libraries ended up in /var/lib/gems/1.8/gems/ on my machine, which is the default gem install path for the Ubuntu Rubygems package. Obviously the DebGem repositories supply updates for Rubygems, so it might become unneccessary to have manual installs of Rubygems in order to get latest versions. I will try this the next days and keep you updated.

Until then, I can only say that this project is very promising, but obviously still far from maturity. On the other hand, just think of setting up the whole Rails stack on a vanilla Ubuntu/Debian machine through a custom .deb package containing your projects dependencies (ruby1.8, rubygems1.8, rails, passenger, apache2 and so on). The Brightbox passenger debs and DebGem might get us there in no time!

Update, January 7th: The Phusion guys have updated the datamapper (which after a version update also is libdatamapper0.9.9-ruby1.8) debgem, so now it won't install all these gems I listed above anymore. I am currently testing the whole thing in a vanilla Ubuntu VM, so stay tuned for a future post on that!

{:merb => "1.0"}.merge(:rails => "2.3") => {:rails => "3.0"}

2009-01-06

Two weeks after the official announcement has been made by David, I finally managed to catch up on my Google Reader, and get to know these exciting news probably as the completely last person on earth: Merb is going to be merged into Rails to become the single greatest piece of software ever created!

If anyone apart of me also missed out on this (I really hope I am actually not the only one who enjoyed holidays away from the screen), be sure to also check out the announcements and opinions posted by new Rails core member Yehuda Katz (who gets into detail on how the merger can be accomplished), Merb founder Ezra Zygmuntowicz as well as Merb developer and Engine Yard employee Carl Lerche, which I actually found the most interesting read because it shows the uniqueness of the whole event of two distinct projects, each fighting for their own goals and having fundamental disagreements on the requirements of a kick-ass framework, putting their differences aside and rather joining forces to build something amazing that benefits from the advantages of both.

I've been following the development and achievements of Merb for quite a while, even though I never managed to really get into it and create a project based upon it. Actually what distracted me the most was that I had to relearn some things, which were done differently in Rails, while plenty of stuff could be accomplished the same way. I always liked Merb's aim to achieve a better structure though, for instance the highest-possible level of decoupling of the individual parts of the framework (I am thinking of the possibility to use something different than ActiveRecord in particular) as well as their work on speedup and early embrace of Rack.

The announced enhancements of Rails performance based upon Merb code have already started to take place, as Mike Gunderloy wrote in his most recent "This Week in Edge Rails":

In some of the first fruits of the Rails-Merb team merger, Yehuda Katz took a look at the respond_to method, which is of course heavily used in many Rails applications to allow your controller to format results differently based on the MIME type of the incoming request. After eliminating a call to method_missing and some profiling and tweaking, he reports an 8% improvement in the number of requests per second served with a simple respond_to that switches between three formats. The best part? No change at all required to the code of your application to take advantage of this speedup

This whole thing is gonna be huge for Rails as well as the whole Ruby community! With the cute parts of Merb integrated into Rails and other great stuff like Rails Metal coming up, I am already looking forward to David's keynote at this years RailsConf, in which hopefully he will introduce the greatness of Rails 3 to us, though I don't believe they will have a beta wrapped-up by then (which he is hoping for in the mentioned post).

In more recent news, the "new evangelism team" mentioned by David in the post linked above has been introduced on the official Rails blog today:

Bringing Rails and Merb together is about more than just merging the respective code. We’re also picking up the best ideas from both communities beyond the code. Following on Merb’s success in offering a strong evangelism effort, we’re pleased to announce the creation of the Rails activists:
The mission of the Rails activists is to empower and support the worldwide network of Ruby on Rails users. We do this by publicizing Rails, making adoption easier, and enhancing developer support.

I can only repeat myself: Great stuff coming up!