Plataforma's blog post about Devise says that it's different to the incumbent libraries, Clearance and Authlogic, in that it provides a full stack solution like Clearance (unlike Authlogic) but allows you to use a custom model (not just "User") and gives you customized role support. It also has full i18n (internatiionalization) support out of the box and Plataforma has made available a complete demo app showing off how Devise can work within a small Rails app.

Devise is a full stack authentication system that provides 5 "strategies" out of the box. A strategy for authentication, one for "confirmations" (e-mails, etc), one for "recovering" accounts, one for "remembering" logins over time, and one to "validate" signups. You can, however, add your own strategies depending on what you need to do (they suggest a "invitations" strategy).

Tweet This Post

The print version of Rails In A Nutshell isn't due out till early 2010 but a focus on targeting Rails 3.0 is almost certainly to blame here. On the plus side, the book should be one of the most up to date Rails tomes once 3.0 eventually hits the streets in the next few months. Luckily, O'Reilly are doing "the right thing" and have wisely licensed the text with the Creative Commons Attribution-Noncommercial license and released the work as it is so far through their O'Reilly Open Feedback Publishing System. What this means for you is that you can read it now - here!

As an intriguing aside, it looks like O'Reilly have had the book on the burner for some time now as three years ago they signed up Jeremy Voorhis to write it.

Tweet This Post

Speaking at RailsConf is a great addition to your CV and a lot of RailsConf's speakers have been first timers. From what I've seen over the years, there doesn't seem to be a pattern to who gets in and who doesn't (though bigger names do, certainly, seem to pop up more - but perhaps they submit the most proposals..) and as long as you can come up with a solid Rails-related talk proposal, you're in with a good chance.

The official call for proposals outlines some areas that would be preferred:

• Time-saving developer productivity tips, tricks, and tools
• Patterns and best practices for developing maintainable Rails applications
• Rails Internals
• Complex domain modeling
• Rails development case studies, including application rewrites and organizational bootstrapping
• Making Rails
• Heterogeneous systems integration
• Real-world deployment and scaling
• Making the most out of new Rails features
• Gem and Plugin highlights
• Extending Rails

Proposals are due by 11:59pm Eastern on March 17, 2010 and successful speakers will be notified in April. Good luck!

Tweet This Post

If you've uploaded photos or videos to Flickr or YouTube, you should be familiar with Flash-powered uploading. Instead of selecting a file and then waiting on a precarious HTTP request to send all of the data, Flash based uploading results in a Flash widget doing all of the hard work on screen - you even get upload progress "out of the box."

While you can use Brian's techniques in your own app, he's also put together swfupload_demo, a complete demo app that shows SWFUpload in action to power a MP3 repository of sorts. It not only processes the upload of MP3s but it also uses an embedded MP3 player to let you play the tracks you upload into the app right on the page.

Tweet This Post

So why post about it again here? Well, our readership has grown a lot in the last year and Spree is a strong open source project that's both incredibly useful and worth knowing about in case you have a need for it in the future.

For those who are totally new to Spree, there's a live demo at http://demo.spreecommerce.com/ and an extensive list of features here. Spree has come a long way in the last year - give it a look!

Tweet This Post

Scout has matured a lot since last year and now pitches itself as a general server and application monitoring service, though there's a sidefocus on Rails app monitoring. It's a commercial service but the entry plan is only $19 a month and there's a thirty day trial available.

Compared to other services, Scout is interesting because no Rails plugin installation is required and all analysis is separate from the request cycle. Redeployment isn't even necessary. Scout takes a more passive background role while still collecting all of the data it needs.

One of Scout's new features is the incorporation of the Request Log Analyzer by Willem van Bergen and Bart ten Brinke. This tool analyzes Rails log files and produces performance reports based around several metrics: request times, mean request time, process blockers, database and rendering times, HTTP methods used, HTTP statuses, Rails action cache stats, and similar. You can couple this with Scout's regular graphs and e-mail alert systems to get notified about "interesting" occurrences with your applications right as they happen.

Lastly, Scout has a strong plugin ethos, so it's not like it's just a Rails service - though that's what I'm focusing on here. You can write your own plugins to monitor whatever you like.. so even if you do monitor a Rails app, if you want to monitor another service "on the side" and you're willing to write a plugin, you'll be good to go, all on the same account.

Disclaimer: Scout has no relationship with Ruby/Rails Inside, other than having run a job ad on our jobs board a little while back. I promised to write about them while talking with them at RailsConf 2009, however, and genuinely think it's a service worth checking out :-)

Tweet This Post

Todd Hoff of HighScalability.com then collected together all of the details he could find about Ravelry and put it together into "How Ravelry Scales to 10 Million Requests Using Rails." It's well worth reading through Ravelry's stack info, but if you want the Cliff Notes version they're using:

• Xen virtualization
• HAProxy
• Nginx
• Tokyo Cabinet (for large object storage)
• Nagios
• New Relic
• Amazon S3
• Amazon Cloudfront (for CDN)
• Sphinx
• Memcached

Also worth a visit, if you care to know about Ravelry's history, is this 30 minute interview with Y KNIT - a popular knitting podcast.

Tweet This Post

Seed's WYSIWYG Interface

The Future: Compare and Contrast

Refinery, Radiant, and Seed are all being actively developed but Refinery currently lacks page caching, and will ultimately need to assimilate all of the things that Seed already has before it can be considered a better alternative. As it stands, the re-order/edit-in-place functionality of Seed is preferable to the scheme Refinery presently uses, which places similar technology in the administrative interface. Clearly, in terms of functionality, with having what approximates a WYSIWYG arrangement tool, Seed is quite slick.

It should be mentioned that Seed is currently built upon Rails v2.1.2, and after contacting the author on GitHub, it isn't likely to advance to a newer version of Rails until there is an intrinsic need that requires doing so.

Features and Customization

Both Seed and Refinery use Rails' engines functionality, and you can override the packaged controllers and views by creating your own copies in the vendor directory and customizing them. This makes it straightforward to back-up business data and simplifies the upgrade process to future versions. Seed also provides calendar functionality, as well as differentiation between articles, news entries, and blog entries out of the box, and it also supports displaying YouTube videos as page components. Both Seed and Refinery allow for file uploading and attachments, but I found myself preferentially drawn towards the smooth light-box that Seed employs.

One thing I don't appreciate with Seed is that the images seem programmatically bound to the upper right hand corner of the articles, but that is most definitely something that can be addressed either through tweaking the CSS or the underlying source code. Had it been possible to drag-and-drop the images such that they could be spread into different paragraphs within the articles, Seed would hands down be my favorite CMS for Rails at present, bar none.

Odds and Ends

There is a built-in table-producing page component that uses a simple mark-up of pipe (|) symbols to create evenly spaced tables within features. I've never seen this before and it's quite handy. Seed does a lot for you, straight out of the box, and is a serious contender in the Rails CMS landscape. I personally think that every Ruby CMS should ship with Compass, and adding Compass to Seed is near the top of my to-do list.

Conclusion

I'm pretty actively tracking open-source web technologies, perhaps to a fault, and I've never seen or heard of Seed in my online experience to date. Found via chance as an aberrant search result on GitHub, Seed has impressed me these past weeks and is definitely worthy of a couple of minutes to setup. At present, it's my favorite of the Ruby CMSes, and while I've traditionally found myself tending towards the Sinatra-based Nesta for a lightweight solution, I think Seed is my new go-to solution for a Rails-based CMS.

Quick Setup Instructions

(case of ubuntu server x86_64 running the latest REE based on 1.8.7)
gem install -v=2.1.2 rails
git clone git://github.com/desaperados/seed.git seed
cd seed
cp config/examples/*.yml config/
rake gems:install
emacs config/settings.yml

script/setup demo
be sure to replace the "secret" string as suggested in the environment.rb file ...
script/server
Load http://localhost:3000 in your browser and relish in all that you didn't have to code!

A big thanks to grantmichaels for providing this guest post.

Tweet This Post

Formtastic doesn't just make it easy to whip up basic forms, though. It has some significant advantages over similar plugins:

• It's Rails 2.3 ready
• It's under active development (the last update was yesterday)
• It supports internationalization
• It has full spec coverage
• It can handle belongs_to, has_many, and has_and_belongs_to_many associations out of the box, rendering multi-selects and radio inputs where necessary!
• It doesn't screw around with the existing Rails form helpers

Here's a large form example straight from Formtastic's documentation (which is pretty thorough, you'll be glad to know):

<% semantic_form_for @article do |form| %>

  <% form.inputs :name => "Basic" do %>
    <%= form.input :title %>
    <%= form.input :body %>
    <%= form.input :section %>
    <%= form.input :publication_state, :as => :radio %>
    <%= form.input :category %>
    <%= form.input :allow_comments, :label => "Allow commenting on this article" %>
  <% end %>

  <% form.inputs :name => "Advanced" do %>
    <%= form.input :keywords, :required => false, :hint => "Example: ruby, rails, forms" %>
    <%= form.input :extract, :required => false %>
    <%= form.input :description, :required => false %>
    <%= form.input :url_title, :required => false %>
  <% end %>

  <% form.inputs :name => "Author", :for => :author do |author_form| %>
    <%= author_form.input :first_name %>
    <%= author_form.input :last_name %>
  <% end %>

  <% form.buttons do %>
    <%= form.commit_button %>
  <% end %>

<% end %>

The result is a clean bundle of HTML. Groovy, right? So get reading the documentation and give it a try. It's an awesome plugin.

[ad] Codebase is a fast & reliable git, mercurial & subversion hosting service with complete project management built-in - ticketing, milestones, wikis & time tracking - all under one roof. Click here to try it - free.

Tweet This Post

The first 5 of Matthew's points - in a very basic summary - are:

1. Each controller action only calls one model method other than an initial find or new
2. Only one or two instance variables are shared between each controller and view
3. All model and variable names are both immediately obvious (to a new developer) and as short as possible without using abbreviations.
4. All custom "finds" accessed from more than one place in the code use named_scope instead of a custom method.
5. A .find or .find_by_ is never called in a view or view helper.

To learn the rest, you'll need to check out his article. He doesn't just list the points. He goes into further detail about every one. A great read.

[ad] Jumpstart Lab is offering Rails Jumpstart, an introduction to Ruby on Rails, on 10/31-11/1 in Washington, DC. Save $30 with code "rubyrow"!

Tweet This Post