Clarification about constants in ruby - ruby

Question

I'm trying to build a rest client and since a lot of is almost the same I thought I'd put the actions into a module and just extend the module to get that set of actions and keep the unique bits separate by defining them as a constant, the same constant but each route has it set differently so the end result is a different URL but the same action.
module Common
def list
"some_url/#{Route_Name}.json"
end
end
class Posts
extend Common
Route_Name = 'posts'
end
class Comments
extend Common
Route_Name = 'comments'
end
Comments.list
#=> "some_url/comments.json" what I expect to be outputted
But it just errors, in this example it would error uninitialized constant Common::Route_Name.
How do I get Route_Name to be what I expect it to be?
EDIT:
I kind of solved the issue by changing Route_Name to #route_name, but the problem is that Route_Name is constant, it will never change so it doesn't feel right using an instance variable, even if it does work.

Answer 1

Ruby does constant lookup first by namespace (roughly: where you've nested them) and then by ancestors (what you've inherited from). Because list is declared in Common, lookup starts with Common::Route_Name and can't go any further.
But, when list is called, it's called on Comments or Posts, giving you access to those via self. Instead of leaving Ruby to look for the constant itself, you can use self::Route_Name to make lookup start where you want it.
module Common
def list
"some_url/#{self::Route_Name}.json"
end
end
class Posts
extend Common
Route_Name = 'posts'
end
class Comments
extend Common
Route_Name = 'comments'
end
puts Comments.list #=> some_url/comments.json
puts Posts.list #=> some_url/posts.json

Answer 2

Use const_get instead. It's a method call (compared to lookup by static name). Meaning, that it will start the constant lookup from the bottom of the ancestor hierarchy.
module Common
def list
"some_url/#{const_get('Route_Name')}.json"
end
end
class Posts
extend Common
Route_Name = 'posts'
end
class Comments
extend Common
Route_Name = 'comments'
end
Comments.list # => "some_url/comments.json"
#mtamhankar has a good point about deriving routes from class names. Something like this, perhaps (uses tableize from ActiveSupport)
module Common
def list
"some_url/#{name.tableize}.json"
end
end

Answer 3

I've done something similar to this, where I've defined several controller actions (index, create, etc..) in a module, then just include MyModule in the controller in which I want to use them.
At this point, in my Module I can call self.controller_name to get where I actually am coming from.
So instead of trying to set the Route_Name, you could derive it with something like self.controller_name.tableize or self.class.tableize

Answer 4

#route_name as you mentioned is an instance variable and will work, but I think what you're actually looking for is ##route_name which would make it a class level variable (one per class, not per instance).

Answer 5

A ruby method looks up constants from that method's owner, not the receiver or the class of the receiver. When you access a constant, ruby interpreter looks up the constant along Module.nesting of the calling module or class.
X = 0
module A
X = 1
module B
p Module.nesting #=> [A::B, A]
X = 2
def self.x
X
end
end
end
A::B.x # Try commenting out any 'X = ?' to see the difference
When you call A::B.x, ruby tries to find the constant X in the namespace A::B (i.e. tries to find A::B::X), if found, it stops the lookup and returns that value immediately. If not found, then ruby tries to find X inside A, if still not fount, ruby tries to find X inside the top level namespace, which is Object.
Since classes and modules have a class/module method name which returns the name of the class/module, you can refactor your Common module like this:
module Common
def list
"some_url/#{name.downcase}.json"
end
end
And annihilate all Route_Name = 'xxx'