Module: EnumField::EnumeratedAttribute

Defined in:
lib/enum_field/enumerated_attribute.rb

Instance Method Summary collapse

Instance Method Details

#enumerated_attribute(name_attribute, options = {}) ⇒ Object Also known as: belongs_to_enumerated_attribute

Define an enumerated field of the AR class

  • name_attribute: the name of the field that will be added, for instance role
  • options: Valid options are:
    • id_attribute: the name of the AR column where the enumerated id will be save. Defaults to name_attribute with an _id suffix.
    • class: the class that will be instantiated when name_attribute method is called. Defaults to name_attribute in camelcase form.


40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/enum_field/enumerated_attribute.rb', line 40

def enumerated_attribute(name_attribute, options  = {})
  id_attribute = options[:id_attribute] || (name_attribute.to_s + '_id').to_sym
  klass = options[:class] || name_attribute.to_s.camelcase.constantize
  define_method(name_attribute) do
    (raw = read_attribute(id_attribute)) && klass.find_by_id(raw)
  end

  define_method(name_attribute.to_s + '=') do |value|
    write_attribute(id_attribute, value ? value.id : nil)
  end
end

#has_many_enumerated_attributes(association, options = {}) ⇒ Object

Defines a one-to-many association between an AR class and the enumerated

  • association: the name of the one-to-many association, for instance roles
  • options: Valid options are:
    • through : the name of the AR class needed to persist the one-to-many association. Defaults to AR class in camelcase form concatenated with the enumerated class in camelcase form.
    • class: the enumerated class, it will be instantiated n times when association method is called. Defaults to association in singular camelcase form.


62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/enum_field/enumerated_attribute.rb', line 62

def has_many_enumerated_attributes(association, options = {})
  enum_attr = association.to_s.singularize
  klass     = options[:class]   || enum_attr.camelcase.constantize
  through   = options[:through] || (self.name + klass.name)
  self_attribute = self.name.demodulize.underscore
  association_ids = association.to_s.singularize + '_ids'
  has_many_aux = through.demodulize.underscore.pluralize

  has_many has_many_aux.to_sym, {:class_name => through, :dependent => :destroy}

  define_method(association) do
    self.send(has_many_aux).map(&enum_attr.to_sym)
  end

  define_method(association.to_s + '=') do |values|
    self.send(has_many_aux + '=', values.map{|g| through.constantize.new(self_attribute => self, enum_attr => g)})
  end

  define_method(association_ids) do
     self.send(association).map(&:id)
  end

  define_method(association_ids + '=') do |values|
    self.send(has_many_aux + '=', values.map{|g| g.to_i unless g.blank?}.compact.map{|g_id| through.constantize.new(self_attribute => self, enum_attr + '_id' => g_id) })
  end
end