cfis : Reusing Rails Controllers is a Good Thing

Comment on Reusing Rails Controllers is a Good Thing by Anders Engström

Mon, 11 Feb 2008 12:04:58 -0700

Great post.

I’ve been avoiding the ‘render_component’ stuff purely from what I’ve read about the awful performance.

At the same time I’ve been missing the way Java JSP/Servlets handles “includes” - which is superior to the :partial/filter alternative recommended by Rails.

I will definitely experiment with ‘render_component’ to replace my existing mix of “render :partial” and “periodically_call_remote”.

Comment on Reusing Rails Controllers is a Good Thing by Tony Maston

Tue, 12 Feb 2008 02:29:29 -0700

Code reuse is not a hopeless endeavour unless you have less-than-competent programmers. Reusable controllers are not a pipe dream. My MVC framework for web applications has a set of 30 page controllers which service over 2000 transactions. No only that, but each page is rendered via an XSL stylesheet, and there are only 11 stylesheets in my XSL library. How’s that for reusability?

The catch? My framework is not RoR, it is Radicore (http://www.radicore.org). It is not written in the Ruby language, it uses PHP. It does not use ActiveRecord, it uses a data dictionary. It does not use an ORM as each object relates directly to a database table.

Comment on Reusing Rails Controllers is a Good Thing by Viktor

Tue, 12 Feb 2008 05:11:12 -0700

It is not actually unusual to be reusing codes. Especially for practicality’s sake. It even shows how much talent one has because you get to make codes so versatile.

Comment on Reusing Rails Controllers is a Good Thing by Peyton

Tue, 12 Feb 2008 05:15:03 -0700

Thank you for sharing the knowledge on Rails controller. I learned a lot of things regarding this matter. In terms of application, models and views are well explained.

Trackback from Justin's Blog: Widgets are better than components on Reusing Rails Controllers is a Good Thing

Tue, 12 Feb 2008 18:10:17 -0700

[This article](http://cfis.savagexi.com/articles/2008/02/11/reusing-rails-controllers-is-a-good-thing) made it across my RSS reader today. I ran into my own problem with this while writing a custom CMS for work. We wanted to have reusable componen...

Trackback from Justin's Blog: Sidebars are better than components on Reusing Rails Controllers is a Good Thing

Tue, 12 Feb 2008 18:40:02 -0700

Comment on Reusing Rails Controllers is a Good Thing by Piers Cawley

Wed, 13 Feb 2008 00:53:52 -0700

At work, we’ve got several independent units on each page and we’ve taken to wrapping the reusable units up inside helpers.

The helper’s then free to do pretty much anything to render its output. It can:

Just render a partial
Select and then render a partial depending on, say, whether a user is logged in.
Toddle off to the database and fetch a bunch of objects to render
Go the whole render_component hog.

The key thing is to pull the act of rendering the partial up into the helper - you write your views to a simple, uniform interface and keep your logic in .rb files.

I’d rather see code like:

<%= comment_widgets @comments %>

than

<%= render :partial => 'comment', :collection => @comments %>

especially when I can implement comment_widgets and comment_widget in a declarative style like:

widget :comment

Implementation of widget is left as an exercise for the interested reader; it’s not exactly tricky.

Comment on Reusing Rails Controllers is a Good Thing by Charlie

Wed, 13 Feb 2008 02:47:05 -0700

Hi Tony,

Actually I think its the other way around - code reuse is only possible if you have competent programmers.

For SIAS, we used XSL stylesheets on the server side to convert XML to HTML. It would have been great to move the XSL transformation to the client, but back then there was no way it was going to work. In the end I’ve moved away from XSL, because writing programs in XML is fairly awful. What have your experiences been?

Comment on Reusing Rails Controllers is a Good Thing by Charlie

Wed, 13 Feb 2008 02:51:07 -0700

Viktor - So I take it you’re not a believer in YAGNI?

Obviously code reuse is a good thing within an application - it just seems that fact was lost in the Rails community in the big hubbub over components.

Comment on Reusing Rails Controllers is a Good Thing by Charlie

Wed, 13 Feb 2008 02:51:43 -0700

Hey Peyton - No problem…

Comment on Reusing Rails Controllers is a Good Thing by Charlie

Wed, 13 Feb 2008 02:57:56 -0700

Welcome back Piers - I was hoping you’d share your experiences with Typo and the move away from using sidebar controllers to using a system based on partials. Did you draw any conclusions in the process?

As far as using helpers instead of partials I’m torn. I see where you are coming from, but I really find generating HTML using ERB much more pleasant. I suppose you’d point on that you just have your helper render the partial, but then you’re adding an extra level on indirection that doesn’t gain you much.

You’re only one step away from self rendering components though…

Comment on Reusing Rails Controllers is a Good Thing by Piers Cawley

Thu, 14 Feb 2008 11:05:53 -0700

I’m not sure that self rendering components is a particularly bad way to go though. I’m not a big fan of templating in general and ERB in particular - I prefer Haml for my personal work because it DRYs up so much of the noise of HTML/ERB, which helps you see ugliness in the code that much quicker.

I think it’s instructive too, to think about how you’d go about implementing something like Facebook in rails, where pages like the profile page are pretty much entirely componentized. You’re pretty much obliged to have some kind of component system where components know how to render themselves independently of the rest of the page.

Typo’s sidebars are a cut down version of this approach - the best trick they have up their sleeves, to my way of thinking anyway is the way their configuration system works. There’s a standardised set of setting types which allows an administrative view to reflect on the sidebar’s class and generate a form for each instance of the sidebar. I’m still rather proud of that. I’m thinking of extending it to a wider typo plugin system which will fire callbacks at various points in the request/render cycle, allowing plugins to customize various almost any aspect of the process. The use case I have in mind is a plugin to implement captchas, both because a captcha system will go into typo’s core over my cold dead body and because a well implemented captcha scheme needs to plug into various parts of the request/render cycle.

Which is tangential to what you’re writing about, but, I hope, still interesting.

Comment on Reusing Rails Controllers is a Good Thing by Stijn

Fri, 15 Feb 2008 06:13:29 -0700

I ran into this article the other day : http://kurt.karmalab.org/articles/2008/02/13/bringing-components-back-into-rails-with-cells It’s about a plugin ‘cells’ (http://cells.rubyforge.org/)

Seems like a neat solution for the whole “rails components” issue.

It depends on the engines-plugin (http://www.rails-engines.org/), which looks quite “heavy”. Anybody experience with this ?

Comment on Reusing Rails Controllers is a Good Thing by Peter Bex

Tue, 26 Feb 2008 02:01:39 -0700

Actually, Engines is not heavy at all, especially since Rails 2. It’s basically regular Rails Plugins with some monkeypatching of the class finding methods, nothing more.

Also, the main reason “components” are slow is that (afaik) you can’t pass complete objects to them. This would mean you create a wall between your current controller and the one you’re rendering as a component, which means you will need to hit the database everytime you want to use the same object in different components. this is the main performance bottleneck: the request stack only allows you to pass strings (via the params hash)

Cells do not have this problem, you can just pass real objects to the Cells. Besides performance this has the benefit of being able to pass modified-but-not-yet-saved objects to the components (for rendering validation errors, for example, something I’ve done in a Cells-using project of mine)

Comment on Reusing Rails Controllers is a Good Thing by Anton

Tue, 04 Mar 2008 01:59:50 -0700

Now that REST is the core of Rails 2.0 its even more an issue to think about render_component. I personaly have the impression it slows dones the performance more than 50% but however. I am using it even I am not really happy with the req/sec.

It would be good to know how you can tune it at least a little bit and still following DRY and REST.