Core/Local which is better?

Question

I recently fell into an interesting argument.

My question is when should we use the local codepool to completely overwrite a class and when should we use Magento class overrides extending a class.

What are the pros and cons of using local copy over rewriting a class.

Answer 1

That is an easy one: you should never use core, but always local.

Or did I misunderstand the question?

Update:

Reasons are simple as well. If you overwrite files in core and then update your shop (i.e. update the core folder) to a new version, all your modifications will be lost and you will need to search all the files if you have modifications.

In contrast, when you have modifications in local, you know which files are edited and can diff them to the new files.

However, the best case is to use rewrites in your own custom module, so you do not need to completely replace a file and can just modify it to your needs.

Second update:

Your question really is why you should avoid overwriting in local and instead use a rewrite!?

If so: It is better to do a rewrite than put the file in local, since chances are that your rewrite will work with a new version of Magento while your local file won't. Why is this?

Let us assume you want to overwrite class A which has 100 methods. You only need to modify one method let's call it "testMethod()".

So in your rewrite, you will extend from the core class and only implement that one method. In contrast, when copying it to local and then change that method, you have overwritten the whole file (so 100 methods).

Now you update your shop and the class A now has 140 methods (40 new methods created by Magento Core team). Your rewrite still rewrites only one method, so all 139 other methods are preserved. However, your local file still has 100 methods, so 40 methods are missing...

So a rewrite has the potential to still work after an update - it could be that the method you are overwriting still needs to be modified, but chances are everything still works.

Answer 2

Here is the order in which you should customize core features.
Start from the top and if one option is not possible go to the next one.

1. Observers
2. Class rewrites
3. Copy class to local folder.
4. Edit the core - Do this only if you want the universe to implode on itself.

The observers approach is the safest. Observers usually don't disappear on an upgrade and they act like a black box. You always know what goes in and what should come out. And you can easily remove it when not needed.

The class rewrites is a bit riskier that the observers approach. In the event of an update some class methods might be changed and if you changed that method you might lose the functionality added by the upgrade or even worse..."white screen of death". But since not everything is observable you can choose this. Here is an example that is killing me. When sending an e-mail there is no observer to pass additional template vars to the e-mail template.

Copy class to local is risky as "h..eck". when an upgrade is done, if something in the class changes ...well you are on the same case as the one above but with a higher chance of happening. You should use this only if you need to change something in abstract classes, or classes that are never instantiated. More words about it here. http://marius-strajeru.blogspot.ro/2011/09/why-cant-you-override-some-classes-in.html

Core modifications...if you do this you deserve what's coming. I speak from experience.