Re-implemented support for updating a belongs to association from the foreign key

The write_attribute case isn't particularly interesting to me, if you're using that you're 'painting outside the lines'

However the case which covers multiple belongs_to associations definitely is more interesting and something that should be addressed.

Seems it should be possible to take that one generated foo_id= method and make it figure out the different associations which use that id and invalidate them all?

Failing that we should revert the feature.

OK, I'm going to revert this functionality till post 2.2

I still think that doing this in attribute writer is not ok.

When someone overrides attribute writer he/she uses 'write_attribute' and not 'super' to invoke original implementation. If only attribute writer has association validation logic, then we have no way to override foreign keys writers.

hmm, that's a compelling point.

Can you give us an updated rebased patch with a commit message explaining the feature rather than comparing it to the previous implementation?

Ok. Will do that today.

Uploading. But I'm not happy with it right now. The problem is that there are many places where association is read (via #instance_variable_get), and all that places need to be modified to check for association stale-ness. I'm uploading it in as-is state, where not all such places are covered.

Extra work needs to be done if this approach is taken. It seems that we need generic association reader method that in addition forcing reload will be able to skip reload. And we'll need to convert #instance_variable_get invokations to invokations of this new method.

Could we perhaps push this logic into the proxy class itself? It knows the owner and the attribute that it matches?

It'd make it a lot less intrusive than having to change everywhere?

Change detection is indeed placed in proxy in my patch. But the code which should run this detection and drop the proxy should not IMO belong to proxy. That's because we cannot use #reset and must simply drop reference on old proxy.

I'll try to complete this work this weekend. I think there's no other way to support this feature.

What's the reason that we have to drop the reference to the old proxy rather than replacing the target internally? Seems more encapsulated that way?

Consider this:

parent = record.parent

old_id = parent.id

record.parent_id = new_id

assert_equal old_id, parent.id # will not fail

record.parent # here parent discovers that foreign key change and turns to completely other object

assert_equal old_id, parent.id # will fail

The reason is that proxy is often used instead of it's target object and it's mostly transparent. Reseting proxy will look like mysterious change of object's identity.

Original implementation had same problem due to use of #reset.

BTW, because belong_to proxies are loaded eagerly (to be able to return nil, which cannot be emulated via #method_missing magic) we can try to return proxy's target instead of proxy itself. Actually, this way it looks much better and this approach should be tried.

Right, the eager loading for nil support is a bloody good point :)

Give that a go and see what the patch comes out like, it sounds like it'll possibly be a little nicer.