Chris Cruft

The HasManyThroughAssociation is awesome.  But the documentation is a bit thin.  I wanted to create an builder method on the association proxy that would check for the presence of an existing join model record before creating a new one with the << method (aliased as push and concat).  This could be done trivially with a validates_uniqueness_of validation on the association model, but that approach produces an AR validation exception when there is an existing record.  To combat this, I decided to write an association proxy extension called add_if_missing.  The trick is to make it compact and to reuse as much of the existing code as possible.  To meet those objectives, I decided

1. Adding the join model record would come with all the restrictions currently in place for the << method (no join model attributes, just foreign keys!)
2. The uniqueness test would use the through association’s find method.

I relied heavily on three relatively new variables available to the association proxy.  In the list below, consider the example Man :has_many Grandchildren :through Children:

• proxy_reflection - the reflection describing the relationship (Man to Grandchildren)
• proxy_target - the association member(s) (set of Grandchildren)
• proxy_owner - the AR instance to which the association is related (@man).

This was my first cut:

def add_if_missing(a)
  through = proxy_reflection.through_reflection
  klass = through.klass
  klass.exists?(through.primary_key_name.to_s => proxy_owner.id, proxy_reflection.association_foreign_key.to_s => a.id) ? self : self << a
end

Unfortunately, it fails to take into consideration any options of the association such as finder and counter sql, uniq, etc.

def add_if_missing(a)
  through = proxy_reflection.through_reflection
  count = proxy_owner.send(through.name).count(:conditions => {proxy_reflection.association_foreign_key.to_s => a.id})
  count == 0 ? self << a : self
end

This version falls back on the through association itself to determine if the record already exists by counting the number of records in the association.

Question: Why, with all the nice query methods available on the association, is there not an exists? method?

References:

1. activerecord/lib/activerecord/associations.rb
2. activerecord/lib/activerecord/reflection.rb
3. activerecord/lib/activerecord/associations/has_many_through_association.rb
4. activerecord/lib/activerecord/associations/has_many_association.rb
5. http://blog.hasmanythrough.com/2006/8/19/magic-join-model-creation

I’m trying to use the following:

    Versamail (version 3.1E on a Treo650 and version 3.5 on a Treo680)
    dovecot version 1.0

Potentially a nice combo, but with the following issues:
    Subfolders can’t be detected by Versamail (formerly known at Palm as Multimail).  Consequently, you can only add them by “creating” them in Versamail with the following syntax:

    ParentFolder.SubFolder

The ParentFolder must be visible (a child of the root folder).  I have not tried deeper constructs (ParentFolder.SubFolder.SubSubFolder), but I suspect they work.

Palm’s technical resources, as usual, are aimed at the “average” user and, as usual, completely lacking in any detail of how to get the job done in the real world (where most average users have some extra-ordinary requirements).

I’ve had problems getting Rail’s automatic parsing of form-encoded XML parameters to handle arrays.  After reading up on XMLSimple I thought I had it figured out: use the anon tag to create the array.  Alas, it’s just not that simple.  RoR takes the input from XMLSimple and recursively invokes ActiveSupport::CoreExtensions::Conversions.typecast_xml_value against the result.  This nasty method forces all zero element arrays to nil and all single element arrays to a scalar value.  Thus, even if I could override RoR’s invocation of XMLSimple (in Hash.from_xml), I would get bitten by the nasty restriction in typecast_xml_value if I tried to use that method’s otherwise desirable functionality.

My lament: why does RoR not allow consistent handling of arrays parsed from the XML?  You really can’t rely on the default behavior of Rails to produce reliable arrays from XML.