In Ruby, for ImportJob < Job that prepends Redacted and includes ConsoleLog then FileLog, what does ancestors return, and where do extended modules fit?

## The full search order For a method call on an object, Ruby searches, in this order: 1. The object's **singleton class** (methods defined on that one object), then modules the object was **extended** with, most recent first. 2. Modules **prepended** to the object's class, the most recently prepended first. 3. The **class** itself. 4. Modules **included** into the class, the most recently included first. 5. The **superclass**, with steps 2 to 4 repeated for it, and so on up to `Object`, `Kernel` and `BasicObject`. `Module#ancestors` on the class shows steps 2 to 5. `obj.singleton_class.ancestors` adds step 1 in front. ## A worked example ```ruby module Redacted; def log(msg) = "redacted(#{super})"; end module ConsoleLog; def log(msg) = "console: #{msg}"; end module FileLog; def log(msg) = "file(#{super})"; end module Timestamped; def log(msg) = "ts(#{super})"; end class Job include Timestamped def log(msg) = "job: #{msg}" end class ImportJob < Job prepend Redacted include ConsoleLog include FileLog end ImportJob.ancestors.take(6) # => [Redacted, ImportJob, FileLog, ConsoleLog, Job, Timestamped] ImportJob.new.log("row 7") # => "redacted(file(console: row 7))" ``` The call starts at `Redacted`, whose `super` reaches `ImportJob` (no `log` there), then `FileLog`, whose `super` reaches `ConsoleLog`, which returns without calling `super`, so `Job#log` and `Timestamped#log` never run. ## Last first, and the one-call exception Each `include` inserts the module **directly after the class**, pushing earlier includes further back. That is why separate calls produce "last included, first searched". The same holds for `prepend`: each new prepend goes to the very front of the chain, ahead of earlier prepends. A single call with several arguments is different. `include(A, B)` is documented as calling `append_features` on each argument **in reverse order**: `B` is inserted first, then `A` in front of it, so the final order matches the order you wrote. | Code in the class body | Resulting order after the class | |---|---| | `include ConsoleLog` then `include FileLog` | `FileLog, ConsoleLog` | | `include ConsoleLog, FileLog` | `ConsoleLog, FileLog` | | `prepend A` then `prepend B` | `B, A` before the class | | `prepend A, B` | `A, B` before the class | ## Where one object's modules go Methods defined on a single object, and modules it was extended with, live in that object's singleton class, which Ruby searches before anything in the class chain: ```ruby job = ImportJob.new job.extend(Audit) job.singleton_class.ancestors.take(4) # => [#<Class:#<ImportJob:0x...>>, Audit, Redacted, ImportJob] ``` So a module extended onto one object beats even a module prepended to its class. The exception is a module the class chain already contains, such as `Timestamped` through `Job`: extending with it adds nothing, because Ruby skips a module that is already anywhere further along the chain, so it cannot be moved in front that way. ## Common prediction mistakes - Putting included modules in the order they appear in the file. Separate `include` calls end up newest first. - Treating a prepend like an include with higher priority but still after the class. A prepended module is searched **before** the class's own methods. - Forgetting the superclass's modules. `Job`'s includes sit between `Job` and `Object`, not at the end of the list. - Assuming an extended module can be moved in front by extending again. If the module is already anywhere in the chain, extending or including it again changes nothing. - Mixing up the instance chain and the class-method chain. Class methods are searched through the singleton classes of the class and its superclasses. ## Predicting in an interview - Write the class in the middle, prepends to its left (newest leftmost), includes to its right (newest nearest the class). - Append the superclass and repeat the pattern for it. - For a specific object, put its singleton class and extended modules in front. - Then scan left to right for the first definition of the method; follow `super` calls to the right.