Planetaki Planet Ruby on Rails

Named Scope: It's Not Just for Conditions, Ya Know?

2008-08-20T15:52:02+00:00

Named scopes in Rails are great, everybody knows that. They’re usually used to create granular, chainable sets of SQL conditions that nicely encapsulate your domain query logic. Here’s a simple example:

class Article < ActiveRecord::Base
  
  # Get all articles that have been published
  named_scope :published, :conditions => ['published = ?', true]

  # Get all articles that were created recently
  named_scope :recent, lambda { { :conditions => ['created_at >= ?', 1.week.ago] } }

end

# Get all recently created articles that have been published
Article.published.recent #=> [<Article id: ...>, <..>]

However, as much as I use named_scope for this purpose, I also use it for some smaller and still useful functions. For instance, I find that I often need to just fetch the first X number of results for any particular query. Instead of having to call find with the :limit option you could create the following named_scope:

class Article < ActiveRecord::Base
  
  # Only get the first X results
  named_scope :limited, lambda { |num| { :limit => num } }

end

# Get the first 5 articles - instead of Article.find(:all, :limit => 5)
Article.limited(5) #=> [<Article id: ...>, <..>]

Hey, any less typing I’ll take, and I find myself using this limited named_scope a lot. But let’s pimp it a little so that you don’t always have to supply the number, and make it default to the per_page value that exists on the class if you’re using will_paginate.

class Article < ActiveRecord::Base
  
  # Only get the first X results.  If no arg is given then try to
  # use the per_page value that will_paginate uses.  If that
  # doesn't exist then use 10
  named_scope :limited, lambda { |*num|
    { :limit => num.flatten.first || (defined?(per_page) ? per_page : 10) }
  }

  def per_page; 15; end

end

# Get the first 15 articles
Article.limited #=> [<Article id: ...>, <..>]

# Get the first 5 articles
Article.limited(5) #=> [<Article id: ...>, <..>]

Note that we have to use the variable length *num argument in the lambda to allow for no arguments.

Cool, so we’ve got a handy little tool for our toolbox now. Here’s another one I find myself using that isn’t strictly a conditional scope – ordered:

class Article < ActiveRecord::Base
  
  # Order the results by the given argument, or 'created_at DESC'
  # if no arg is given
  named_scope :ordered, lambda { |*order|
    { :order => order.flatten.first || 'created_at DESC' }
  }

end

# Get all articles ordered by 'created_at DESC'
Article.ordered #=> [<Article id: ...>, <..>]

# Get all articles ordered by 'updated_at DESC'
Article.ordered('updated_at DESC') #=> [<Article id: ...>, <..>]

I’ve bundled these scopes up into a “utility scopes:http://github.com/yfactorial/utility_scopes” plugin/gem if you think they look useful to you. I’ve also added some class-level convenience initializers to let you override the default values (like the default limit and default order clause):

class Article < ActiveRecord::Base

  # This class's default ordering (if not specified
  # defaults to 'created_at DESC'
  ordered_by 'published_at DESC'
  
  # By default, return 15 results (if not specified
  # defaults to 10
  default_limit 15

end

# Get the first 15 articles ordered by 'published_at DESC'
Article.ordered.limited #=> [<Article id: ...>, <..>]

# Get the first 15 articles ordered by 'popularity ASC'
Article.ordered('popularity ASC').limited #=> [<Article id: ...>, <..>]

# Get the first 20 articles ordered by 'popularity ASC'
Article.ordered('popularity ASC').limited(20) #=> [<Article id: ...>, <..>]

Need a little something else? How about the with scope which will eager load the specified associations:

class Article < ActiveRecord::Base
  has_many :comments
  has_many :contributors, :class_name => 'User'
end

# Get the first 10 articles along with their comments, comment authors and article contributors
Article.limit(10).with({ :comments => :author }, :contributors)

You can get all these goodies yourself by doing the following in your Rails 2.1 app. In config/environment.rb specify the gem dependency:

Rails::Initializer.run do |config|
  # ...
  config.gem "yfactorial-utility_scopes", :lib => 'utility_scopes', 
    :source => 'http://gems.github.com/'
end

And then to get the utility_scopes gem actually installed on your system:

rake gems:install GEM=yfactorial-utility_scopes

Or you can just install the gem as you normally would:

sudo gem install yfactorial-utility_scopes -s http://gems.github.com

Independent of whether or not you find these scopes useful, remember that named_scope is all up in your queries’ bidness – not just your queries’ conditions

Have some utility scopes you find to be indispensable? Let me know here or send me a request on github (user is yfactorial).

tags: ruby, rubyonrails

Web Spidering con Ruby on Rails, el vídeo de Volcanica

2008-08-20T12:53:50+00:00

Boris, la araña volcánica, la película:

…este es el vídeo de la charla sobre web spidering que dirigí el año pasado en Volcanica. El sonido no es muy bueno porque había ruido de fondo de la sala de al lado pero se agradece de todos modos!

También están disponibles las presentaciones para su descarga: introduccion_ruby_on_rails y ruby-web_spidering.

Puedes ver los vídeos de todo Volcanica 2007 en su web.

Este año cambiaré de tema y hablaré sólo de Ruby.

Cómo evitar la regeneración de thumbnails con attachment_fu

2008-08-20T09:19:54+00:00

attachment_fu es seguramente el plugin de subida de adjuntos más usado actualmente en el mundillo Rails, aunque seguido bastante de cerca por el nuevo y también recomendable paperclip.

Un comportamiento que no me gusta de attachment_fu es que tras cada actualización del modelo, regenera el conjunto de thumbnails. Está bien que tras la creación de la foto procese la imagen para generar todos sus thumbnails, pero no me parece buena idea que si simplemente quieres actualizar cualquier otro dato del modelo, se vuelva a regenerar el conjunto de thumbnails.

Por ejemplo, si tienes un modelo Foto con todos los campos de attachment_fu pero además un campo título… cada vez que actualices la foto aunque sólo sea para cambiarle el título, se volverá a procesar la imagen para generar los thumbnails, dándole carga innecesaria al servidor.

Afortunadamente esto es código libre y fácil de entender así que mirando el fichero attachment_fu.rb, podemos encontrar esta línea que es la que hace que tras cada .save del modelo se procese el adjunto:

base.after_save :after_process_attachment

basta con cambiarla a esto:

base.after_create :after_process_attachment

para que sólo lo haga tras la creación del adjunto, y no en sucesivas actualizaciones.

Sería interesante mirarlo más en profundidad para que sí lo haga en caso de que le estemos pasando un nuevo fichero de imagen, pero por el momento me vale para mis propósitos… y de todos modos quizá es hora de irse cambiando a paperclip, que por lo que tengo entendido, no tiene este comportamiento… aunque tampoco es del todo cómodo porque he leído que para regenerar los thumbnails en paperclip es necesario lanzar una tarea rake.

Cerrado por vacaciones

2008-08-19T17:10:27+00:00

Tras largos meses de intensa actividad haciendo malabarismos entre varios proyectos, llegó al fin el momento de la pausa veraniega. ¡Me marcho de vacaciones hasta el 8 de septiembre!

Aprovecharé para descansar, montar en bici, dar largos paseos, descubrir alguna ciudad nueva si me lo permite Ryanair y, por qué no, estudiar alguno de esos libros de Ruby que compré en su día y tan buena pinta tienen.

Nos vemos a la vuelta! Que descanséis también vosotros!

My attempt at sake task management

2008-08-19T04:55:32+00:00

I’ve used sake intermittently in my workflow. It competes against me writing helper/admin scripts in my ~/ruby/bin folder. Normally, executable Ruby scripts have won. But I think I have a new solution that could make sake a permanent winner for me.

Ruby scripts are easy to create and execute. You just open new file, change the TextMate grammar to ‘Ruby’, type ‘rb’ and press TAB and you’re off and running (the ‘rb’ snippet generates #!/usr/bin/env ruby or a variation of that). You then make the file executable and BAM! you can run the script from any folder in your environment.

Sake tasks are more annoying to write. After creating a new file, you need to create the namespace and task wrappers for your functionality, such as:

namespace 'foo' do
  namespace 'bar' do
    desc "This task ..."
    task :baz do

    end
  end
end

Your task isn’t instantly executable either. After each change, you need to uninstall the task (sake -u foo:bar:baz) and then reinstall the sake file (sake -i foo/bar/baz.sake) and then run it (sake foo:bar:baz). Perhaps there’s a way to inline edit a sake task, but I can’t see it from the help options.

But once you’ve got your script installed in sake, you get all the wonders that sake provides: a named list (with summary) of tasks (sake -T) and the ability to run those tasks anywhere. Ok, that’s really only one advantage over standard Ruby scripts. But I like it. Oh, namespacing. The baz task exists in a namespace foo:bar. That’s nice too.

So to make me happy, I need a solution to the dubious “create-install-execute” process above. I also want the raw source for all my sake tasks in one place so I can fix/add/change them, reinstall them and move on with my life. I want simple.

So I’ve forked Chris Wanstrath’s empty sake-tasks repo (mine) and added some infrastructure for managing sake tasks. Of course the repo itself is the repository for my sake tasks (which includes a lot from Luke Melia), but most importantly it has a single rake task to reinstall all the tasks without any manual fuss.

The rest of this article assumes you want to have your own repository for your own sake tasks hosted on github. This paragraph is probably unnecessary, but I don’t want to be accused of not being mildly thorough.

Fork the sake-tasks repo

For thoroughness and a chance to demonstrate some gold-medal git-fu, I’ll show two ways: fork my repo and forking the original repo from Chris and pulling my stuff into yours. It’s git, it’s distributed, you can do anything.

If you want to fork my repo and skip a nifty git lesson, go to my sake-tasks repo and click “fork”. Then follow the clone instructions as you normally do when you are blatantly, systematically duplicating someone else’s hard work, using a command that will look something like:

git clone git@github.com:your-github-username/sake-tasks.git

Now, lazy man, you can skip to the next step.

If you want to flex your git-fu, then go and fork Chris’ repo instead. Again, follow the clone instructions.

Now take a moment to reflect on just how empty your repository is. A fine moment in open-source where you’ve essentially cloned an empty repository. Hardly worth the effort, but since Chris is a creator of github then if he creates an empty repository then who am I to disagree. Empty it shall start.

Now let’s pull in the code and tasks from my repo. My repo could be any git repo anywhere on the tubes.

One way you could pull my code into your local repository is to add my repo as a remote and then pull in the goodness:

git remote add drnic git://github.com:drnic/sake-tasks.git
git pull drnic master

This is useful if you ever plan on re-pulling from a target repo again in the future.

If you just want to pull from someone’s repo one time only, then you can merge these two lines together:

git pull git://github.com:drnic/sake-tasks.git master

If you get occasional pull requests for your projects, then the latter option is handy to know.

Your local repo is now different to your remote repo (your fork on github) so push it back to your remote:

git push origin master

Installing the sake tasks

I originally created my sake-tasks fork so I could store a git:manpages:install task. I’ve just upgraded to git 1.6 (note to self: I want an ‘upgrade to latest git version via src’ task) and found some instructions for installing the pre-built manpages. Then I got over excited and refactored all of Luke Melia’s git+mysql+ssh tasks in to my repo so it looked like I’d done a lot of work.

To install all the tasks, first install sake:

sudo gem install sake

Then run the install task (check below for the list of tasks to be installed):

WARNING: This will uninstall any tasks you already have by the same name.

rake install

Now, check that your sake tasks are installed:

sake -T

Gives you:

sake git:analyze:commits:flog_frequent   # Flog the most commonly revised files in the git history
sake git:close                           # Delete the current branch and switch back to master
sake git:manpages:install                # Install man pages for current git version
sake git:open                            # Create a new branch off master
sake git:pull                            # Pull new commits from the repository
sake git:push                            # Push all changes to the repository
sake git:status                          # Show the current status of the checkout
sake git:topic                           # Create a new topic branch
sake git:update                          # Pull new commits from the repository
sake mysql:dump                          # Dump the database to FILE (depends on mysql:params)
sake mysql:load                          # Load the database from FILE (depends on mysql:params)
sake ssh:install_public_key              # Install your public key on a remote server.

Sexy.

Adding new recipes/tasks

The installer rake task rake install works by assuming that each .sake file contains one sake task. This allows the rake task to uninstall the tasks from sake first, and then re-install it (sake barfs if you attempt to reinstall an existing task). Without the one-task-per-file rule, the solution would be to load all the sake tasks as rake tasks into memory. But I like one-task-per-file; it seems clean.

So, to create a task foo:bar:baz, you’ll need to add a folder foo/bar and create a file baz.sake inside it. Within that file you would then specify your task using namespace and task method calls:

namespace 'foo' do
  namespace 'bar' do
    desc "This task ..."
    task :baz do

    end
  end
end

To install new tasks or reinstall modified tasks, just run the rake task (rake install or rake).

TextMate users

The latest Ruby.tmbundle on github includes a task command that generates the above namespace/task snippet based on the path + file name. That is, inside the foo/bar/baz.sake file, make sure your grammar is ‘Ruby’ or ‘Ruby on Rails’ and then type “task” and press TAB. The above snippet will be generated ready for you to specify your task.

Summary

So now I have a single place for all my original sake source and a simple rake task to re-install the tasks if I add or modify them. And because its all in one git repo, if other people fork it and add their own tasks then I can steal them.

Finding Good Rails Training in Your Area

2008-08-19T01:47:12+00:00

I just wanted to take a quick moment to recognize the Ruby On Rails Workshops site. It’s provided by Geoffrey Grosenbach. It’s been around for as long as I can remember (ok, probably since 2006, I guess?), and always lists the top-notch events that are happening in the Ruby/Rails world.

I really like the way you can filter the results by country. Or use the calendar to quickly get a monthly listing (and even hover over a date in the calendar to see what classes are on that day).

For example, here are the workshops coming up in the US.

Thanks to Geoffrey for continuing to maintaining the site and continuing to make it available as a service to the Ruby and Rails communities.

Ready to learn all about REST with Rails? Our next workshop is coming up fast (Oct 4, 2008), so register now before all the seats are taken.

Episode 123: Subdomains

2008-08-18T11:50:22+00:00

Learn how to unleash the full potential of subdomains with the subdomain-fu Rails plugin in this episode.

Do Your Own (Ruby) Olympics

2008-08-18T05:46:40+00:00

Suppose someone told you that they are an Olympic athlete. What would you know about them? You could safely assume that they’re in great physical shape. But you’d have to ask more questions: what kind of athlete are you? Are you a swimmer? A runner? Maybe you do archery?

Even knowing the sport might not reveal all of their talents. For example, many Olympic events have a variety of events associated with them. To qualify for the swim team, you have to swim in multiple ways: freestyle, butterfly, backstroke, and breast stroke. Gymnasts also have to be good at a lot of things to be considered Olympic material: not only the floor exercise, but also the pommel horse, vault, and rings, and I don’t know what else.

Swimmers who only excel at freestyle swimming might be great at freestyle swimming, but they’ll never really be able to be good enough to make the Olympic team. Gymnasts who are great at the pommel horse, but never bother to learn the other disciplines, won’t make the team either.

Umm… Isn’t This Blog About Rails?

Ok, I’m getting to the point… Perhaps you currently consider yourself to be a real cool Rails developer. But do you really take the time to learn all of different skills that entails?

If there was a Rails event at the Olympics, would you qualify?

Here are the main “events” that I think Rails developers need to be good at to be considered “Olympic” quality.

Ruby

First and foremost, how is your Ruby? When was the last time you learned something new about Ruby? I don’t mean Rails. I mean Ruby. If you haven’t been able to refactor your code into something simpler and clearer, then you probably need to spend more time with the Ruby language.

ActiveRecord

ActiveRecord has actually gotten pretty big. Some features may exist that you don’t know about, or don’t know how to use (has_many :through and named_scope come to mind). Learn them. Use them. They can simplify your code. Not sure about the difference between association proxies and arrays? Wondering what SQL calls ActiveRecord is really making on your behalf? Then it’s time to do some strength conditioning and learn more about it.

Views

Maybe you’re feeling pretty good with your HTML views. How about your Javascript skills? Are you using the best possible form_for syntax in your views? Have you learned how to use view helpers to DRY up your view code?

SQL

Just because ActiveRecord writes SQL for you doesn’t mean you don’t have to learn SQL. It’s a muscle that we Rails developers can avoid using, but that probably mean that it’s atrophied. I know for myself, SQL is probably my weakest link when it comes to Rails development. I need to spend more time in the SQL gym, so I can better understand and improve upon the database performance in my apps.

REST

If you’re not doing RESTful development, but you’re using Rails 1.2 or higher, then you really need to get on the ball. Or maybe you think you’ve got the RESTful thing down pat, but you still end up adding a bunch of custom actions to your controllers. If so, then it’s time to see your friendly neighborhood trainer and get your REST skills in shape. Your apps (and your boss) will thank you.

Anything Else

You probably feel a twinge of guilt about some area of Rails that you know you should get better at, but you just never seem to have the time. Do you know how to write a plugin? Do you know how to contribute a patch to Rails? Do you need to get better with subversion or git? How about deployment? The list could go on and on.

If you want to say you’re a professional Rails developer, you can’t just be good at script/generate model Product. Identify what you want to learn next, and learn it.

Have you learned something recently that really helped you get to the next level in your Rails coding? Or, is there a weak area that you know you want to get better at? Drop us a comment and let us know.

Ready to learn all about REST with Rails? Our next workshop is coming up fast (Oct 4, 2008), so register now before all the seats are taken.

Sorting things out

2008-08-17T18:05:23+00:00

I recently packed up everything I own and moved. I'd lived in my old place for about nine years and I have the packrat gene on both sides of the family tree, so I had a lot of crap to sort through to figure out what to move and what to trash, as well as which box what should go in. Now that I'm here in the new place, I've had to sort through the remaining stuff to figure out where it all goes. So you might appreciate that sorting has been on my mind a lot lately. (See? It's a topical tie-in. I don't do those often, so I hope it wasn't too awkward.)

I've also been working on an application that does a lot of sorting to prioritize tasks in a workflow. These items often need to be sorted based on multiple criteria, such as how long an application has been waiting for approval, how many times a customer has been called recently, etc. We also have to sort names that have anywhere from two to four components (Hispanic names can have both paternal and maternal names instead of just a surname).

Ruby enumerables can be sorted using the #sort method, which orders contents using the <=> trinary comparison operator. It's pretty simple to override <=> if instances of a class are only ever sorted one way, but when you get to a situation where you need to sort things in different ways depending on the context, you need a more flexible solution

The next obvious thing to try is passing a block to the #sort method. This works great, but it has two drawbacks. One, if the sort criteria are complex, you can end up with some ugly looking code. And B, it's not very DRY for re-using sort criteria.

The approach I came up with for my application makes use of the sorting properties of Ruby arrays. Ruby arrays sort quite nicely using the <=> operator. <=> compares two arrays by comparing all their values until a non-equal result is found for any pairings of values in the two arrays. Here are some example comparisons:

>> [1, 2, 3] <=> [1, 2, 3]
=> 0
>> [0, 2, 3] <=> [1, 2, 3]
=> -1
>> [1, 2, 3] <=> [0, 2, 3]
=> 1
>> [1, 2, [4, 5]] <=> [1, 2, [6, 7]]
=> -1
>> [1, 2, [4, 5]] <=> [1, 2, [2, 3]]
=> 1

There are some things to watch out for, like don't have nil anywhere in the array contents, and shorter arrays sort less than longer arrays where all else is equal. But this is a great feature to build upon.

Based on the array sorting functionality, I defined a concept I call a sorter. A sorter is an array that holds multiple values to use to sort the collection by in order of precedence. For example, if you want to sort people by name using the precedence paternal, maternal, first, middle, you can construct an array of those values and sort the list using that.

class Person < ActiveRecord::Base
  def name_sorter
    [(paternal_name || ""), (maternal_name || ""), (first_name || ""), (middle_name || "")]
  end
end

@people = Person.find(:all).sort_by { |p| p.name_sorter }

Notice I'm making sure that I never have a nil as a value in the sorter, cause that will make things blow up like the ending of a Die Hard movie. If you want to avoid that verbiage, set up the model so that the names default to empty strings. Also notice that I'm using the #sort_by method, instead of the #sort method with a 2-arg block. Actually, let's look at all our options. The following three forms will give equivalent results:

@people = Person.find(:all).sort_by { |p| p.name_sorter }
@people = Person.find(:all).sort_by(&:name_sorter)
@people = Person.find(:all).sort { |a,b| a.name_sorter <=> b.name_sorter }

The first line is the one I'd use in most situations. The second line is slightly more compact, but the symbol-to-proc coercion should be avoided in any code where you care about performance (at least until Ruby 1.9 is ready for prime time). The third line is usually going to be a bad choice, because a sorter array would be created for every time its person was compared, which will be roughly ln(n) times if you are willing to believe my naive assumptions about Ruby's sorting algorithm. If you don't want to trust naiveté, check out the simple performance comparison I ran. This benchmark sorts an array of 60 items using a sorter on 4 values.

                user     system      total        real
sort        6.430000   0.000000   6.430000 (  6.466645)
sort_by     1.510000   0.000000   1.510000 (  1.509017)

That kind of difference is pretty significant to me. Of course, if your sorter can be cached so you can reuse it for multiple comparisons, a #sort might be better. As always, measure it if you care and you're not sure.

One last thing. What if we just rolled the sort by hand using a block? (The code below assumes names will default to an empty string.)

@people = Person.find(:all).sort do |a,b|
  if    0 != (comp = a.last_name <=> b.last_name)
    comp
  elsif 0 != (comp = a.maternal_name <=> b.maternal_name)
    comp
  elsif 0 != (comp = a.first_name <=> b.first_name)
    comp
  else
    a.middle_name <=> b.middle_name
  end
end

That's fairly ugly and it's actually slower than the #sort_by approach too.

And because I don't believe in secret benchmarks, here is a gist of the benchmark code I used.

Now if you'll excuse me, I have a lot of empty cardboard boxes to toss in the recycling.

Josh Peek officially joins the Rails core

2008-08-19T04:38:59+00:00

Josh Peek has been a defacto Rails core committer for a while, but for some reason we’ve never actually made the appointment official. So here it goes: Josh Peek is the latest Rails core team member. Three cheers hurray!

Josh has been working on a Google Summer of Code project to bring thread safety to Rails and is just about ready to wrap it up. Rails 2.2 will be thread safe thanks to the work that Josh has put into it.

Of more importance, though, is the significant effort put into making things faster and cleaner as part of that push. The actual thread safety won’t really matter much to most people, but it’ll surely look nice on your enterprisey check list of Features Your Framework Must Have To Get Play Around Here.

In any case, please welcome Josh!

Cloning Ubuntu Hardy image in VMWare Fusion

2008-08-15T23:40:03+00:00

Having spent the better part of a day googling and struggling, I figured it would possibly benefit others if I took a minute to post the steps I took to clone a VMWare Fusion image. The image in question is of Ubuntu Server (Hardy). I’m using VMWare Fusion 2 (beta 2).

Just find your “Virtual Machines” folder (should be in your Documents folder), and copy the image in question to a new location. (The images are actually folders; a simple “cp -R” worked fine for me.)

Then, open the copied image in VMWare Fusion and boot it. VMWare Fusion will ask if you if you copied or moved the image—be sure to say you copied it (that let’s VMWare set up a new MAC address for your image).

Go ahead and log in once the server boots. You’ll find networking is all hosed. To fix networking, this worked for me:

“sudo hostname blah”, to set the hostname. This doesn’t change it permanently, so you’ll also want to:
“sudo vim /etc/hostname”. Change the contents of the file to the hostname you want. Then:
“sudo vim /etc/hosts”. Replace all mentions of the old hostname with the new hostname.
“sudo vim /etc/udev/rules.d/70-persistent-net.rules”. There will be two entries in this file. The first points eth0 at the old MAC address, and the second points eth1 at the new. Go ahead and delete the first entry, and change “eth1” to “eth0” in the second (and now only) entry.
“sudo shutdown -r now” to restart your virtual machine.

Once your machine comes back up, you should have a network again! Now, if only VMWare Fusion could bake all this in somehow… :/

(Related: installing VMWare Tools on Ubuntu server. It’s from 2006, but it still worked well enough for me, though I followed the instructions for tweaking the network that the VMWare Tools install gave at the end, rather than what this gent said.)

Ruby on Rails Google Group Getting Better

2008-08-14T21:32:30+00:00

Frederick Cheung has done a great job eliminating the spam problem that had been plaguing the Ruby on Rails Google Group. I had more or less abandoned the group months ago, because the value of the group had plummeted.

But lately I’ve enjoyed posting questions and answers there again. If you have never tried the Google Group (also mirrored here if you prefer a different UI than Google’s), I recommend it.

Thanks to Frederick for volunteering his time and energy to serve the Rails community this way.

New to REST in Rails? Join us at REST with Rails Oct 4, 2008, in Austin, TX

Tutorial #2: Recap

2008-08-14T21:32:13+00:00

So, the second Capistrano tutorial session has come and gone. It was a great session, though it started pretty rough. (I was very unprepared for some windows-related configuration issues during the first half-hour. That won’t happen again.) I appreciate everyone’s patience who participated!

I’m going to be quiet on the tutorial front for the next several weeks, but its not because I’ve given up on them. I’m going to be rethinking some aspects of them. I really want these to be opportunities for people to master capistrano, and while these first two tutorials have been very useful to those who attended (their words, not mine), I think they could be even better.

Stay tuned!

What's New in Edge Rails: Simpler Conditional Get Support (ETags)

2008-08-14T01:12:27+00:00

Conditional-gets are a facility of the HTTP spec that provide a way for web servers to tell browsers that the response to a GET request hasn’t changed since the last request and can be safely pulled from the browser cache.

They work by using the HTTP_IF_NONE_MATCH and HTTP_IF_MODIFIED_SINCE headers to pass back and forth both a unique content identifier and the timestamp of when the content was last changed. If the browser makes a request where the content identifier (etag) or last modified since timestamp matches the server’s version then the server only needs to send back an empty response with a not modified status.

It is the server’s (i.e. our) responsibility to look for a last modified timestamp and the if-none-match header and determine whether or not to send back the full response. With this new conditional-get support in rails this is a pretty easy task:

class ArticlesController < ApplicationController

  def show
    @article = Article.find(params[:id])

    # Set the response headers to accurately reflect the state of the
    # requested object(s)
    response.last_modified = @article.published_at.utc
    response.etag = @article

    # If the request's state is the same as the server's state then we know
    # we don't have to send back the whole body
    if request.fresh?(response)
      head :not_modified
    else
      respond_to do |wants|
        # normal response processing
      end
    end
end

The etag value is calculated for you with the etag= setter method. All you have to do is provide a single object or array of objects that uniquely identify this request. In this example the article itself contains all the information that uniquely identifies the state of this request. However, you may need to use more than one key in your app. For instance, if the request is user specific:

response.etag = [@article, current_user]

The request.fresh?(response) method is what will then tell you if the incoming request matches either the last-modified-since or if-none-match values of the outgoing response. If it does you can avoid passing the full body of the response back and save some bandwidth.

It’s also possible that you can avoid hitting the database all together if your application deals with completely static resources (though this is rare):

class ArticlesController < ApplicationController

  def show

    # If articles don't change, the etag can be based solely
    # on items we have in the request
    response.etag = [:article, params[:id]]

    # If the request's state is the same as the server's state then we can
    # avoid the db call all together
    if request.fresh?(response)
      head :not_modified
    else
      @article = Article.find(params[:id])
      respond_to do |wants|
        ...
      end
    end
end

So be a good citizen and make your requests conditional-get compatible. It’s the right thing to do – and can make your apps more performant.

tags: ruby, rubyonrails

Charlas sobre Ruby y Shoes en Volcanica

2008-08-12T11:51:57+00:00

El año pasado dí un par de charlas sobre Rails en el evento Volcanica, y para la edición de este año (19, 20 y 21 de septiembre) me apetece centrarme más en Ruby…

Estas son mis propuestas para este año, una sobre introducción a Ruby y otra sobre Shoes, el toolkit para aplicaciones de escritorio con Ruby que me está divirtiendo tantísimo últimamente.

####################
1.- Programación en Ruby
####################

Ruby es un lenguaje de programación dinámico y de código abierto enfocado en la simplicidad y productividad, entre cuyos principios de diseño está el maximizar la felicidad del programador haciéndole la vida más fácil.

En este taller daremos un repaso a la sintaxis de Ruby, con ejemplos prácticos de programación y de uso de algunas de las librerías más interesantes de que dispone el lenguaje.

http://www.ruby-lang.org/es/about/

###############################
2.- Shoes, programación gráfica con Ruby
###############################

El lenguaje de programación Ruby no está limitado al desarrollo web y scripts de mantenimiento, sino que puede ser empleado también para la programación de aplicaciones de escritorio con interfaz gráfica basada en ventanas.

Shoes es un toolkit que nos permite programar aplicaciones de ventanas multiplataforma con muy pocas líneas de código, empleando Ruby. Además sus capacidades para gráficos, animaciones, y audio nos permiten programar juegos y demos.

Las posibilidades de Shoes y la sencillez de su sintaxis lo hace muy apropiado para enseñar a programar a niños, así como a los adultos que echamos de menos los años dorados del ZX Spectrum

http://code.whytheluckystiff.net/shoes
http://www.the-shoebox.org/

Más información sobre el evento Volcanica en:

http://www.volcanica.cat

Episode 122: Passenger in Development

2008-08-11T11:43:38+00:00

Tired of juggling multiple Rails apps around with script/server? See how to set up Passenger in development so each one has its own local domain name.

REST with Rails: Registration Now Open

2008-08-10T15:26:27+00:00

Registration is officially now open for REST with Rails, coming to Austin, Texas on Saturday, October 4, 2008.

REST with Rails

When: Saturday, October 4, 2008, 8:30am – 5:00pm

Where: FiveRuns Offices: 209 West 9th Street, Suite 100, Austin, Texas 78701

Cost: $295.00

If you’re new to REST and want to learn what all the fuss is about, join us for a fun, one-day workshop! We’ll cover all the basics of RESTful development with Rails. This class is geared for those new to REST, regardless of how long you’ve been using Rails. (We assume you can at least create a simple Rails app, but not much more than that.)

All of our workshops have a friendly atmosphere. There really are no dumb questions. We use an informative combination of slides and live coding demos instead of long, boring powerpoint presentations.

And, thanks to FiveRuns, this public workshop will be held at their brand new offices in downtown Austin, Texas!

Seating is quite limited, so read all about it and then sign up!

(Those who signed up for early notification should have received your discount code. If for some reason you didn’t get it, please let us know.)

Thanks, and we hope to see you there!

Conversión de moneda con Google y Ruby

2008-08-19T17:10:27+00:00

Tras leer esta idea de Albert Coronado para convertir moneda con Google y PHP, se me ha ocurrido probar a hacer lo mismo con Ruby, y este es el resultado:

require 'open-uri'

class ConversorMonedaGoogle

  def self.euro_a_dolar
    google = open("http://google.es/search?q=1+Euro+to+%24").read
    pos_euro = google.index("1 Euro = ")
    pos_dolar = google.index("US$")

    google[pos_euro+9 .. pos_dolar-2]
  end

end

# Llamada de prueba...
puts "El euro está hoy a #{ConversorMonedaGoogle.euro_a_dolar} dólares según Google"

Básicamente, usamos la librería estándar open-uri para leer los resultados de buscar en Google “1 Euro to $”, y después buscamos el resultado mirando en el HTML devuelto como si fuera lo que es, simplemente una cadena de texto.

Como apunta Albert, hay que tener en cuenta que para usar esto en serio tendríamos que hacer cache del resultado, apuntarlo en base de datos, lo que sea, pero no estar consultando continuamente a Google porque sería muy lento.

Pero como idea, es divertido y además lo podemos extender a otras conversiones que nos proporciona Google

Hackfest

2008-08-20T13:36:09+00:00

And once again, hackfest is back. Only this time, it’s better than ever, thanks to Git

The idea is quite simple. You get 5000 points for each of your patches that get merged to the core. The person with the highest points at the end of the month wins.

August hackfest is already on and almost 3 more weeks to go, so hack on for the first prize – a free pass to RailsConf Europe ( special thanks goes to O’Reilly for the prize )

If you’ve never contributed to Rails before, now is a good time. This railscast is a nice head start.

Thanks to all those who have contributed to Rails, making it better and better.

Using Rails Generators

2008-08-05T20:25:14+00:00

Most people who start learning Rails today quickly learn about generators. They’re easy to use and very handy.

Still, like any other code-generation device, it’s important to understand what they’re doing when you use them. I thought that would go without saying, but I should know better. I remember back in the day of ATL COM programming on Windows, adoption of ATL really took off when Visual Studio added a few wizards to help you create COM components easily. The number of people who didn’t realize what it was doing was surprising. When the smallest bug or issue would come up, they were at a loss to know what their program was doing. To be fair, I also didn’t know what the wizards were doing when I started learning, either. I finally learned how to create COM components by hand (IDL….yuck), and once I did a couple, I knew everything I needed to know. Using the wizards after that was fun and helpful, since I knew how to change (or fix) anything I needed to after the wizard had generated its code.

Ok, back to the present… once in a while I notice that people don’t really understand Rails generators. I don’t really think it’s worth a blog post to explain all of them, but I did want to mention a quick tip that you might not already be aware of if you’ve just recently started with Rails: if you do this,

c:\myapp> ruby script\generate

(and then wait a minute) you’ll get a page showing all the options and generators available.

You can get specific help on a generator (say, the scaffold generator) like this:

c:\myapp> ruby script\generate scaffold

The help that’s emitted to the console is dense but usually quite complete.

Just do me one favor: after using a generator, learn what it did for you. There’s nothing a generator can do that you can’t do yourself. They just take the tedium out of some common Rails tasks that you’d otherwise have to do by hand.

Now, if you’d like to see an article on a specific generator, or have other questions about Rails generators, just drop us a comment here.

New to REST in Rails? Come to REST with Rails Oct 4, 2008, in Austin, TX

Analiza los cuellos de botella de MySQL con Query-Reviewer

2008-08-05T18:42:54+00:00

A raíz del artículo “4 simple steps to detect & fix slow rails requests” he descubierto un plugin muy interesante para detectar cuellos de botella en las consultas a MySQL desde nuestras aplicaciones Rails.

Se trata de query-reviewer, que se encarga de mostrarnos avisos directamente con una capa flotante en el navegador, cuando estamos en modo de desarrollo. El plugin analiza las consultas realizadas y nos indica si todo va bien, o muestra los avisos de que hay cosas que se podrían mejorar, por qué y cómo.

Tras un rato examinando los avisos generados y siguiendo sus consejos para añadir índices a las tablas y contadores a algunas asociaciones en los modelos, he incrementado por 3 la velocidad de respuesta de algunas de las partes de mis aplicaciones.

Conferencia Rails 2008… here we go again!

2008-08-05T07:12:04+00:00

Aunque este año hemos tardado un poco en arrancar, el equipo de organización de la Conferencia Rails estamos de nuevo a la carga organizando el evento.

Ya nos puedes enviar tus propuestas de charlas, tanto si son ponencias técnicas como casos de éxito (qué mejor ocasión para promocionar tu nueva app)…

Toda la información actualizada en el blog oficial, www.conferenciarails.org y en nuestro canal de twitter, twitter.com/conferenciaror

Online Capistrano Tutorial #2

2008-08-04T17:06:32+00:00

The first online Capistrano tutorial session was very successful, thanks to everyone who participated. Now, it’s time to try again!

The second online Capistrano tutorial session is now open for registration: http://events.capify.org/events/2.

It is scheduled for Wednesday, August 13th, at 7pm (Mountain time), and will last two hours (plus up to an hour at the end for Q&A;). As before, this tutorial is targeted at beginning Capistrano users, those will little or no prior experience. (If you’re looking for a session for more advanced users, keep watching this space—I’ll probably do one of those eventually, as soon as I can write a curriculum for it.)

Episode 121: Non Active Record Model

2008-08-04T11:58:23+00:00

This episode will show you how to make a model which isn't based on Active Record. You may want to do this if a resource isn't backed by the database.

Dr Nic for hire

2008-08-04T06:06:32+00:00

For the last few months I’ve been contracting to three different projects, and then recently two of them finished, with the third being an on-going project for the last two years which will be launched at DEMO in a months’ time.

So I’m excited to start looking for a new consulting project to work on.

Travel or relocation is an option. Full-time salary is probably not an option. Either full-time or several days-per-week is an option. Making me wear a uniform and serve hamburgers through a small window is not an option. Working in an office is an option. Working on an oil rig in the Indian Ocean is not an option.

My professional background is in telecom billing systems and third-party integrations, including a roving two year stint in various countries between 2005 and 2007 (India, Sweden, Netherlands and Germany). One part of me is excited by the idea of moving overseas again. The other part of me includes two small children and a ten-hour plane flight to get anywhere.

I do have a PhD from the University of Queensland, though the only proof of it I can find on the InterTubes is on my supervisor’s 1990’s-themed website.

In recent years I’ve worked on several Rails projects, including developing and coaching the founders of imindi.com, a next-generation service for individual and collaborative thinking. I’ve run a bunch of Introduction to Rails workshops. I’m with a small group of Australians who recently started soliciting to develop iPhone SDK + Rails applications (under the brand Mocra; also, see Garath Townsend’s free app I Am Here which is in the top 50 free apps at the moment).

I’ve written dozens and dozens of blog articles (see an amusing graph); authored or hijacked or nudged along dozens and dozens of Ruby projects, JavaScript thingies, and TextMate bundles (see my github profile). I’ve even been allowed to talk at various conferences (my favourite talk was the RubiGen session at RubyConf 2007 [video]), including the exciting Rails Summit Latin American in Brazil later this year.

Open Source is for free and Consulting is for money. In both cases I like to work hard, write lots of code, and accumulate and share knowledge.

It would be wonderful if you can share this post with anyone who would benefit from having me on their team.

I can be contacted at drnicwilliams@gmail.com or on +61 412 002 126 in GMT+10 time zone.