# Lineage of a Ruby Class

The other day I was writing some code in which I needed to know if a specific class was a descendant of another class.

I've done a similar thing with Ruby objects in the past, but never with classes, and I think I'll start from there.

If we want to know if a Ruby object's class is a descendant of the Vehicle class, we can simply ask it if it is a Vehicle

  Vehicle = Class.new
Animal  = Class.new

Car = Class.new(Vehicle)
Dog = Class.new(Animal)

Car.new.is_a?(Vehicle)          # => true
Dog.new.is_a?(Vehicle)          # => false

And we can even go one level down in the lineage an it'll still answer as espected

  Sedan = Class.new(Car)
Sedan.new.is_a?(Car)            # => true

But when asking the same thing to a class, the story is different. And for that, I want to show you my specific use case.

I had a class called Field that represented a field in a form. A form could have many fields and so on.

This was part of a Form Objects library, and in that library I wanted a small DSL that allowed me to create a field and assign a type (it has more than than, but I'll simplify)

  class MyForm < Form
field :name, String
#     ^      ^
#     |      Field type
#     Field name
end

This method created 2 new instance methods on the form: a getter and a setter. And that setter needed to know the type we needed and set the apropriate value.

If the field type was Field or any descendant, the value is unchanged, but if it's something else, we needed to wrap it in a Field (getting a uniform level of abstraction).

  class Form
def self.field(field_name, field_type)
define_method field_name do
instance_variable_get "@#{field_name}"
end

define_method "#{field_name}=" do |raw_value|
value = if <type_is_field>
raw_value
else
Field.for(raw_value)
end

instance_variable_set "@#{field_name}", value
end

end
end

Let's center our focus in that placeholder.

My first approach was to use is_a? out of habit. But as it turns out always returned false:

  Field = Class.new

String.is_a? Field         # => false
Field.is_a? Field          # => false

And that's because I'm always passing a class in.

Now, seeing it as in the last example seams dumb on my part. But on my defense, I was seeing something like this:

  field_type.is_a? Field          # => false

Because I was asking it to a variable passed in (and also, this particular case came in after several days of developing the library).

So I had to investigate how to do it. The first thing I did was just asking the class if it's ancestors included the Field class.

  field_type.ancestors.include?(Field)

And this got my specs passing. But after looking at it for some time, I started finding that approach more and more annoying. It was very verbose and un-Ruby-like to me, so I went where every developer goes in these cases… Stackoverflow.

I found out that the Class class in Ruby defines the < operator to ask exactly what I wanted to ask: Are you a descendant of Field?

  Field   = Class.new
MyField = Class.new(Field)

MyField < Field    # => true

And it's not just limited to that, it defines all the comparison operators, so we can ask for ancestors or descendants with this idiom, which is absolutely awesome to me

  MyField < Field      # => true
Field   < Field      # => false

MyField <= Field     # => true
Field   <= Field     # => true

Field   > MyField    # => true
Field   > Field      # => false

Field   >= MyField   # => true
Field   >= Field     # => true

So next time you need to know about the lineage of a class, you have an excellent short-hand to do so. Thanks Ruby!