Question

Basically I want to implement a simple Rails extension to define the seriousness of methods in my controller so that I can restrict usage of them appropriately. For example I’d define the default restful actions as so in an abstract superclass:

view_methods :index, :show
edit_methods :new, :create, :edit, :update
destroy_methods :destroy

I’d then down in a non-abstract controller call:

edit_methods :sort

to add in the sort method on that particular controller as being an edit level method.

I could then use a before_filter to check the level of the action currently being performed, and abort it if my logic determines that the current user can’t do it.

Trouble is, I’m having trouble working out how to set up this kind of structure. I’ve tried something like this so far:

class ApplicationController

  @@view_methods = Array.new
  @@edit_methods = Array.new
  @@destroy_methods = Array.new

  def self.view_methods(*view_methods)
    class_variable_set(:@@view_methods, class_variable_get(:@@view_methods) << view_methods.to_a)
  end

  def self.edit_methods(*edit_methods)
    class_variable_set(:@@edit_methods, self.class_variable_get(:@@edit_methods) << edit_methods.to_a)
  end

  def self.destroy_methods(*destroy_methods)
    @@destroy_methods << destroy_methods.to_a
  end

  def self.testing
    return @@edit_methods
  end


  view_methods :index, :show
  edit_methods :new, :create, :edit, :update
  destroy_methods :destroy

end

The three methods above are different on purpose, just to show you what I’ve tried. The third one works, but returns the same results no matter what controller I test. Probably because the class variables are stored in the application controller so are changed globally.

Any help would be greatly appreciated.

Answer 1

The problem is that your class variables are inherited, but point to the same instance of Array. If you update one, it will also be updated on all classes that inherited the Array.

ActiveSupport offers a solution to this problem by extending the Class class with several methods to define inheritable class attributes. They are used everywhere internally in Rails. An example:

class ApplicationController
  class_inheritable_array :view_method_list
  self.view_method_list = []

  def self.view_methods(*view_methods)
    self.view_method_list = view_methods  # view_methods are added
  end

  view_methods :index, :show
end

Now you can set default values in ApplicationController and override them later.

class MyController < ApplicationController
  view_method :my_method
end

ApplicationController.view_method_list #=> [:index, :show]
MyController.view_method_list #=> [:index, :show, :my_method]

You can even use the view_method_list as an instance method on the controllers (e.g. MyController.new.view_method_list).

In your example you didn’t define a way to remove methods from the lists, but the idea is to do something like the following (in case you need it):

# given the code above...
class MyController
  self.view_method_list.delete :show
end
MyController.view_method_list #=> [:index, :my_method]