Another way to output helper instead of eval - ruby-on-rails

Question

(#products + #collections + #users + #questions).map do |r|
#results << {
:label => ["Product", "Collection", "User"].include?(r.class.name) ? r.name : r.question,
:category => r.class.name,
:href => eval("#{r.class.name.downcase}_path(r)")
}
end
I am currently looking if there is a way not to use eval on the string to convert it to a helper.
Note: This code is currently in the controller. Rails 2.3.11

Answer 1

Use polymorphic_path
#results = (#products + #collections + #users + #questions).map do |r|
{
:label => ["Product", "Collection", "User"].include?(r.class.name) ? r.name : r.question,
:category => r.class.name,
:href => polymorphic_path(r)
}
end

Answer 2

You can try something like this:
:href => self.send("#{r.class.name.downcase}_path".to_sym, r)
Since I'm not totally sure of the context here I'm not 100% confident this will work, but if this is a method you're trying to reference, then self is the most likely target for it.

Answer 3

There's 3 ways you can dynamically call methods with benchmarks shown here. I'l summarize the article below:
One way to invoke a method dynamically in ruby is to send a message to the object :
p s.send(:length) #=> 6
p s.send(:include?,"hi") #=> true
A second way is instantiate a method object and then call it:
method_object = s.method(:length)
p method_object.call #=> 6
method_object = s.method(:include?)
p method_object.call('hi') #=> true
And the third way is to use the eval method:
eval "s.length" #=> 6
eval "s.include? 'hi'" #=>true
According to the benchmarks results the SLOWEST is eval so I'd use send instead.
#######################################
##### The results
#######################################
#Rehearsal ----------------------------------------
#call 0.050000 0.020000 0.070000 ( 0.077915)
#send 0.080000 0.000000 0.080000 ( 0.086071)
#eval 0.360000 0.040000 0.400000 ( 0.405647)
#------------------------------- total: 0.550000sec
# user system total real
#call 0.050000 0.020000 0.070000 ( 0.072041)
#send 0.070000 0.000000 0.070000 ( 0.077674)
#eval 0.370000 0.020000 0.390000 ( 0.399442)

Answer 4

There are a few things you should be doing different, some of which have been alluded to or explicitly stated in other answers, but I think this does a better job:
#results = (#products + #collections + #users + #questions).map do |r|
{
:label => r.try(:question) || r.name,
:category => r.class.model_name.human,
:href => send(:"#{r.class.model_name.underscore}_path", r)
}
end
You don't need to build your result array manually — you're already using map, just assign the result to #results.
There's no need to do all the manual work of determining whether or not you should be posting the question or the name. You could give all these models a to_label method, which would be pretty easy, but assuming that questions don't have names using try and a binary or is just a dead simple way around the problem.
Single word model names convert pretty easily to display titles, but when you end up with a class like BedSheet you're going to want it to display as "Bed Sheet". Might as well do it right to start.
The other side of that same problem is converting the class name to the path/url helper method: you want bed_sheet_path, not bedsheet_path.
Using send over eval, as explained in other answers. No need to use an explicit to_sym though since Ruby supports using double-quotes to create a symbol outright.
Another quick note, I don't know if Rails 2.x was the same, but in Rails 3 you don't need to use the path helper to link to an instance of a model since most html helper methods will convert automatically (e.g. link_to 'A Product', #product).
Voila.

Answer 5

You could use a look-up table:
class_procs = {
Product => {
:path => lambda { |r| product_path(r) },
:label => lambda { |r| r.name }
},
Collection => {
:path => lambda { |r| collection_path(r) },
:label => lambda { |r| r.name }
}
User => {
:path => lambda { |r| user_path(r) },
:label => lambda { |r| r.name }
},
Question => {
:path => lambda { |r| question_path(r) },
:label => lambda { |r| r.question }
}
}
(#products + #collections + #users + #questions).map do |r|
procs = class_procs[r.class]
#results << {
:label => procs[:label].call(r),
:category => r.class.name,
:href => procs[:path].call(r)
}
end
And if your needs get more complicated then you could easily convert the per-class Hashes to individual classes to keep the inner Hashes from getting too big and complicated.