How can I get the class name from an ActiveRecord object?
I have:
result = User.find(1) I tried:
result.class # => User(id: integer, name: string ...) result.to_s # => #<User:0x3d07cdc>" I need only the class name, in a string (User in this case). Is there a method for that?
I know this is pretty basic, but I searched both Rails' and Ruby's docs, and I couldn't find it.
You want to call .name on the object's class:
result.class.name 
result.class.name.split('::').last
result.class.name.demodulize
User.name. User.to_s also seems to work.
Here's the correct answer, extracted from comments by Daniel Rikowski and pseidemann. I'm tired of having to weed through comments to find the right answer...
If you use Rails (ActiveSupport):
result.class.name.demodulize If you use POR (plain-ol-Ruby):
result.class.name.split('::').last 
Both result.class.to_s and result.class.name work.
If you want to get a class name from inside a class method, class.name or self.class.name won't work. These will just output Class, since the class of a class is Class. Instead, you can just use name:
module Foo class Bar def self.say_name puts "I'm a #{name}!" end end end Foo::Bar.say_name output:
I'm a Foo::Bar! 
name, especially in an ActiveRecord model; many models will have a name attribute. If that were the case, how would we get the class name?In Ruby, you'd use the object.class.name method as follows.
module Bank class Account end end irb(main):005:0> account = Bank::Account.new => #<Bank::Account:0x0000000106115b00> irb(main):006:0> account.class.name => "Bank::Account" irb(main):008:0> account.class.name.split("::").last => "Account" In Rails, as others mentioned, you can use the demodulize method on a string, which is added by Active Support. It removes the module part from the constant expression in the string.
irb(main):014:0> account.class.name.demodulize => "Account" Internally, this method calls the demodulize class method on the ActiveSupport::Inflector class, passing itself as the argument.
# File activesupport/lib/active_support/core_ext/string/inflections.rb, line 166 def demodulize ActiveSupport::Inflector.demodulize(self) end The Inflector.demodulize function does the same thing.
demodulize('ActiveSupport::Inflector::Inflections') # => "Inflections" demodulize('Inflections') # => "Inflections" demodulize('::Inflections') # => "Inflections" demodulize('') # => "" However, its internal implementation is different than the simple version above.
# File activesupport/lib/active_support/inflector/methods.rb, line 228 def demodulize(path) path = path.to_s if i = path.rindex("::") path[(i + 2)..-1] else path end end After converting the path argument to a string, it gets the index of the last occurrence of :: using Ruby's rindex function. If it exists, then it returns the remaining substring. Otherwise, it returns the original string. The array[n..-1] expression returns the substring from n to the last character in the string.
Now I haven't done any benchmark studies to find why Rails uses this alternative approach using rindex (please comment if you know why), but as a code readability enthusiast, I like the first one using the split and last functions.
In my case when I use something like result.class.name I got something like Module1::class_name. But if we only want class_name, use
result.class.table_name.singularize
Object#class.inspectgives the same asObject#class.name, whereas this isn't the case with ActiveRecord objects.