Same Class Extension in Two Different Modules

Extend the same class with 2 modules? Magento module conflict?

Eeek - do not try and conditionally declare a class name/extension.

When working with potential class loading and priority conflicts, first remember the PHP autoloader priority (include_path)

It tries in this order:

./app/code/local
./app/code/community
./app/code/core

So anything defined in local will override community, regardless of any internal Magento rewrites.

With your extension, either change the Yoast extension to extend yours. Or, remove the rewrite from the Yoast extension config.xml, and have your extension extend the Yoast one.

And if you happen to want to override the same function, be sure to just

return parent::myfunction()

At the end of your function and then it will carry out the extended class' function.

Simples.

inheritance from multiple modules?

To help you understand that, ruby provides you with Module#ancestors:

Object.ancestors # => [Object, Kernel, BasicObject]

This is the order, in which an instance method of Object will be searched for. So lets test your examples.

---

First, two modules included:

module M; end
module N; end
class C
  include M
  include N
end

C.ancestors # => [C, N, M, Object, Kernel, BasicObject]

So the methods will first be searched for in C. If a method with the given name is not found, it is searched for first in N and then in M. In other words - the reverse order of which you included the modules.

---

Second, module, including a module, included in a class:

module X; end
module Y
  include X
end
class K
  include Y
end

K.ancestors # => [K, Y, X, Object, Kernel, BasicObject]

So we can see that the same rule applies for including in modules. Just as in the previous example a method will first be searched for in C and only then in the modules included in C, here a method will first will be searched for in a module, and only then in the included modules in that module.

---

The reason for that, other than consistency, is that classes are actually modules in Ruby:

Class.superclass # => Module

---

There are a lot of rules. For example including the same module twice in the hierarchy, singleton classes, #prepend, #method_missing and so on. But you can deduce all of it knowing how to use #ancestors.

Extending an object multiple times with the same module in Ruby

I think the subsequent calls are ignored (unless you have something deeper in mind). The following result shows Mod only once in the ancestor list.

class Klass; end
module Mod; end
k = Klass.new
k.extend(Mod)
k.extend(Mod)
k.extend(Mod)
k.singleton_class.ancestors
# => [#<Class:#<Klass:0x007f7787ef7558>>, Mod, Klass, Object, Kernel, BasicObject]

---

Related Topics