Design Review: Business Object Permissions in my Models (Page 1 of 2)

Looks good. I have done something similar, but in my case I placed the permissions in the User model and used Single Table Inheritance for the different roles. What I like about this is it places all permissions in one spot and different roles can override permission through inheritance. Because in your case the role of the user changes based on its relation to an object, I doubt this will work well for you. But, you are welcome to gather ideas from it. Anyway, here's the details:

There's several models that need user permissions for the CRUD (and a couple other) operations. Right now there are 3 roles, but this is fairly easy to change by adding another User subclass: Admin, Member, and Guest.

Here's an example of the view:

<% for widget in @widgets %>
  <% if current_user.can_view_widget? widget %>
    <%= link_to widget.name, widget_url(widget) %>
    <%= link_to 'Edit', edit_widget_url(widget) if current_user.can_update_widget? widget %>
    <%= link_to 'Destroy', widget_url(widget), :method => 'delete' if current_user.can_destroy_widget? widget %>
  <% end %>
<% end %>
<%= link_to 'Create Widget', new_widget_url  if current_user.can_create_widget? %>

class User < ActiveRecord::Base
  def method_missing(call, *args)
    if call.to_s =~ /^can_(\w+)_(\w+)\?$/
      can? $1.to_sym, $2.to_sym, args.first
    else
      super
    end
  end
  def can?(action, item_type, item = nil)
    false
  end
end

class Guest < User
  def can?(action, item_type, item = nil)
    action == :view # Guest can view everything, but has no other permissions
  end
end
class Admin < User
  def can?(action, item_type, item = nil)
    true # Admin can do anything
  end
end
class Member < User
  def can?(action, item_type, item = nil)
    action != :destroy # Member can do anything but destroy items
  end
  def can_destroy_widget?(widget)
    true if widget.user == self # Oh, but he can destroy widgets that he owns
  end
end

Although I have not gone this far yet, I expect to be able to have a before_filter on the controller and forward the params[:action] to this can? method so we don't have to perform a check for permissions in every controller action.

Like I said, I doubt this will work for you because you need the roles to be dynamic, but you may be able to take a few ideas such as the method_missing magic.

ryanb: method_missing is a nice trick. That will reduce the complexity of my implementation. Thanks!

I'm only interested in methods which start with "can_". If it doesn't, then pass it along as if I never interrupted the flow of things. This is so ActiveRecord::Base can have its own method_missing call and do whatever it wants to it.

A dollar sign is a global variable in Ruby. When doing a regular expression like I am here, Ruby fills the $n ($1, $2, $3, etc.) global variables with the content in the parenthesis in the regular expression.

In other words, if it catches the method "can_create_post?" it will fill $1 with "create" and $2 with "post".

The "can?" method is defined early in the User model. It takes a few arguments: the action to perform, the name of the model to perform it on, and the model itself if there is one. "args.first" takes the first argument that was passed to the method and send it to the "can?" method.

For example, if you call this:

user.can_destroy_post? @post

user.can? :destroy, :post, @post

That's a regular expression. Think of it as a very powerful way to search and manipulate text. It is definitely worth taking some time to learn. It's not limited to Rails or even Ruby, it is adopted by many programming languages.