default serializer selection should scope to namespace?

[yoda]

module Fruit
  module Banana
    class SugarSerializer < ActiveModel::Serializer
      has_one :molecule
    end
  end
end

module Fruit
  module Banana
    class MoleculeSerializer < ActiveModel::Serializer
      ...
     end
  end
end

class MoleculeSerializer < ActiveModel::Serializer
  ...
end

class SugarSerializer < ActiveModel::Serializer
  has_one :molecule
end

In my opinion Fruit::Banana::SugarSerializer should serialize the molecule relationships (via include) with the Fruit::Banana::MoleculeSerializer instead of the global namespaced one. If Fruit::Banana::MoleculeSerializer did not exist then it would use the global namepsaced one, or if SugarSerializer was not namepsaced it would use the global namespaced molecule one. I realise I can work around this by explicitly setting the serializer on the relations but its a bit cumbersome.

Reading around http://guides.rubyonrails.org/association_basics.html section 3.4

Indicates:

To associate a model with a model in a different namespace, you must specify the complete class name in your association declaration:

module MyApplication
  module Business
    class Supplier < ActiveRecord::Base
       has_one :account,
        class_name: "MyApplication::Billing::Account"
    end
  end

  module Billing
    class Account < ActiveRecord::Base
       belongs_to :supplier,
        class_name: "MyApplication::Business::Supplier"
    end
  end
end

So I'm thinking this is not really a bug and I just have to bite the bullet and write all of the serializers in.

[beauby]

The docs of master are slightly out of date, but this feature was merged last month. On master, lookup happens exactly as you expect it.

[yoda]

Ah ok, thank you heaps, dang you guys are quick.

[beauby]

ref #1225

[yoda]

I guess my problem is related to this comment from bf4

#1225 (diff)

[beauby]

Could you give an example? I guess one possible extension would be to lookup serializers inside the "root serializer"'s namespace (i.e. the namespace of the serializer of the base resource of a chain of associations). I threw the idea around but it didn't get much traction.

[yoda]

My problem is something like this:

module Fruit
  module Banana
    class SugarSerializer < ActiveModel::Serializer
      has_one :molecule
      class MoleculeSerializer < ActiveModel::Serializer
        attributes :id, :title
      end
    end
  end
end

class MoleculeSerializer < ActiveModel::Serializer
  attributes :id
end

Only seems to use the global scoped MoleculeSerializer and not the nested one. If I remove the global one, it just errors looking for Sugar::Molecule

[beauby]

Hmm that's weird. See, here, it explicitly looks for Fruit::Banana::MoleculeSerializer (and actually not at all for MoleculeSerializer).
Could you a) make sure the problem is still here with master (I'm not sure this was merged pre-RC3), and b) provide a failing test?

[yoda]

Ok I'll look into it

[yoda]

It does seem to be working now for some unknown reason (didnt change anything, just restarted app server a few times while checking stuff). Maybe preloader was playing silly buggers. Also any suggestion if I have an existing thing like this:

module Fruit
  module Banana
    class SugarSerializer < ActiveModel::Serializer
      has_one :molecule

    end
  end
end

module Fruit
  module Banana
    class SaltSerializer < ActiveModel::Serializer
      has_one :molecule

    end
  end
end

module Fruit
  module Banana
    class MoleculeSerializer < ActiveModel::Serializer
      attributes :id, :title
    end
  end
end

To make it use that MoleculeSerializer as the serializer for molecule in Fruit::Banana:: Sugar,Salt? Does one extend it into there or something?

[yoda]

I've gone with:

module Fruit
  module Banana
    class SugarSerializer < ActiveModel::Serializer
      has_one :molecule
      class MoleculeSerializer < ActiveModel::Serializer
        attributes ::Fruit::Banana::MoleculeSerializer.included_attributes
      end
    end
  end
end

# or maybe

module Fruit
  module Banana
    class SaltSerializer < ActiveModel::Serializer
      has_one :molecule
      class MoleculeSerializer < ::Fruit::Banana::MoleculeSerializer
      end

    end
  end
end

module Fruit
  module Banana
    class MoleculeSerializer < ActiveModel::Serializer
      attributes :id, :title
      def self.included_attributes
        [:id, :title]
      end
    end
  end
end

[beauby]

Currently, in your case, the serializers would be correctly inferred only if your models were declared in the Fruit::Banana namespace. Other than that, the use-case you describe (where the namespace of the serializer of the base resource is considered for looking up serializers for associations) is the one I mentioned above, and it is doable without to much effort in the current code base (I had a PR somewhere doing that), so feel free to open an issue making a case for it, and if enough people show interest in this I'll rebase the aforementioned PR.

[yoda]

I think its probably a fairly unusual use case, it happens to me because of a legacy codebase where the existing models are in global scope and I'm lurking off to the side.