Module: EnumAccessor::ClassMethods

Defined in:
lib/enum_accessor.rb

Defined Under Namespace

Classes: Definition

Instance Method Summary collapse

Instance Method Details

#enum_accessor(column, keys, options = {}) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/enum_accessor.rb', line 9

def enum_accessor(column, keys, options={})
  definition = :"#{column}_enum_accessor"
  class_attribute definition # will set instance accessor as well
  send "#{definition}=", Definition.new(column, keys, self)

  # Getter
  define_method(column) do
    send(definition).dict.key(read_attribute(column))
  end

  # Setter
  define_method("#{column}=") do |arg|
    case arg
    when String, Symbol
      write_attribute column, send(definition).dict[arg]
    when Integer, NilClass
      write_attribute column, arg
    end
  end

  # Raw-value getter
  define_method("#{column}_raw") do
    read_attribute(column)
  end

  # Predicate
  send(definition).dict.each do |key, int|
    define_method("#{column}_#{key}?") do
      read_attribute(column) == int
    end
  end

  # Human-friendly print
  define_method("human_#{column}") do
    self.class.send "human_#{column}", send(column)
  end

  # Class methods
  define_singleton_method column.to_s.pluralize do
    send(definition)
  end

  # Human-friendly print on class level
  # Mimics ActiveModel::Translation.human_attribute_name
  define_singleton_method "human_#{column}" do |key, options={}|
    defaults = lookup_ancestors.map do |klass|
      :"#{self.i18n_scope}.enum_accessor.#{klass.model_name.i18n_key}.#{column}.#{key}"
    end
    defaults << :"enum_accessor.#{self.model_name.i18n_key}.#{column}.#{key}"
    defaults << :"enum_accessor.#{column}.#{key}"
    defaults << options.delete(:default) if options[:default]
    defaults << key.to_s.humanize

    options.reverse_merge! count: 1, default: defaults
    I18n.translate(defaults.shift, options)
  end

  # Scopes
  define_singleton_method "where_#{column}" do |*args|
    integers = args.map{|arg| send(definition).dict[arg] }.compact
    where(column => integers)
  end

  # Validation
  if options.has_key?(:validate) or options.has_key?(:validation_options)
    raise ArgumentError, 'validation options are updated. please refer to the documentation.'
  end
  if options[:validates]
    validation_options = options[:validates].is_a?(Hash) ? options[:validates] : {}
    validates column, { inclusion: { in: send(definition).dict.keys } }.merge(validation_options)
  end
end