class Mobility::Backends::Sequel::KeyValue::Translatable

Attributes

belongs_to[R]
id_column[R]
key_column[R]
type_column[R]
value_column[R]

Public Class Methods

new(key_column, value_column, belongs_to) click to toggle source
# File lib/mobility/backends/sequel/key_value.rb, line 226
def initialize(key_column, value_column, belongs_to)
  @key_column = key_column
  @value_column = value_column
  @belongs_to = belongs_to
  @id_column = :"#{belongs_to}_id"
  @type_column = :"#{belongs_to}_type"
end

Public Instance Methods

descendants() click to toggle source

Strictly these are not “descendants”, but to keep terminology consistent with ActiveRecord KeyValue backend.

# File lib/mobility/backends/sequel/key_value.rb, line 236
def descendants
  @descendants ||= Set.new
end
included(base) click to toggle source
Calls superclass method
# File lib/mobility/backends/sequel/key_value.rb, line 240
def included(base)
  @descendants ||= Set.new
  @descendants << base

  mod = self
  key_column = mod.key_column
  id_column = mod.id_column
  type_column = mod.type_column

  base.class_eval do
    plugin :validation_helpers

    # Paraphased from sequel_polymorphic gem
    #
    model = underscore(self.to_s)
    plural_model = pluralize(model)
    many_to_one mod.belongs_to,
      reciprocal: plural_model.to_sym,
      reciprocal_type: :many_to_one,
      setter: (proc do |able_instance|
        self[id_column]   = (able_instance.pk if able_instance)
        self[type_column] = (able_instance.class.name if able_instance)
      end),
      dataset: (proc do
        translatable_type = send type_column
        translatable_id   = send id_column
        return if translatable_type.nil? || translatable_id.nil?
        klass = self.class.send(:constantize, translatable_type)
        klass.where(klass.primary_key => translatable_id)
      end),
      eager_loader: (proc do |eo|
        id_map = {}
        eo[:rows].each do |model|
          model_able_type = model.send type_column
          model_able_id = model.send id_column
          model.associations[belongs_to] = nil
          ((id_map[model_able_type] ||= {})[model_able_id] ||= []) << model if !model_able_type.nil? && !model_able_id.nil?
        end
        id_map.each do |klass_name, id_map|
          klass = constantize(camelize(klass_name))
          klass.where(klass.primary_key=>id_map.keys).all do |related_obj|
            id_map[related_obj.pk].each do |model|
              model.associations[belongs_to] = related_obj
            end
          end
        end
      end)

    define_method :validate do
      super()
      validates_presence [:locale, key_column, id_column, type_column]
      validates_unique   [:locale, key_column, id_column, type_column]
    end
  end
end