Module: HasEnum::ClassMethods

Defined in:
lib/has_enum/class_methods.rb

Instance Method Summary collapse

Instance Method Details

#enum_values(attribute) ⇒ Object 



3
4
5
 
# File 'lib/has_enum/class_methods.rb', line 3

def enum_values(attribute)
  enums[attribute]
end

#has_enum(*params) ⇒ Object

Raises:

  • (ArgumentError) 


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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/has_enum/class_methods.rb', line 27

def has_enum(*params)
  options = params.extract_options!
  options.assert_valid_keys(:query_methods, :scopes, :presence, :multiple, :validates)

  raise ArgumentError, "Empty arguments list for has_enum call" if params.empty?

  default_values = nil
  case params.second
    when NilClass                   # has_enum :enum
      attributes = [*params.first]
    when Array                      # has_enum :enum, %w[foo bar]
      attributes = [*params.first]
      default_values = params.second.map(&:to_s)
    else                            # has_enum :state, :status
      attributes = params
  end

  attributes.map(&:to_sym).each do | attribute |
    values = default_values || human_enum_values(attribute).keys.map(&:to_s)

    enums[attribute] = values

    if options[:multiple]
      serialize attribute, Array
    else
      validates attribute, :inclusion => { :in => values + [nil]} unless options[:validates] == false
    end

    validates attribute, :presence => options[:presence] if options[:presence]

    values.each do |val|
      scope "#{attribute}_#{val}", where(attribute => val)
    end if options[:scopes]

    values.each do |val|
      define_method "#{attribute}_#{val}?" do
         self.send(attribute) == val.to_s
      end
    end if options[:query_methods] != false

    if options[:multiple]
      define_method "human_#{attribute}" do
        return nil if self.send(attribute).empty?
        self.send(attribute).map{|v| self.class.human_enums[attribute][v]}
      end
    else
      define_method "human_#{attribute}" do
        self.class.human_enums[attribute][self[attribute]]
      end
    end

    if options[:multiple]
      define_method "#{attribute}=" do | values |
        self[attribute] = [*values].compact.map(&:to_s).delete_if{|v| v.blank?}
      end
    else
      define_method "#{attribute}=" do | value |
        value = value.to_s
        value = nil if value == ''
        self[attribute] = value
      end
    end

    if options[:multiple]
     define_method attribute do
       self[attribute] ||= []
     end
    end
  end
end

#has_enum?(enum) ⇒ Boolean

Returns:

  • (Boolean) 


7
8
9
 
# File 'lib/has_enum/class_methods.rb', line 7

def has_enum?(enum)
  enums.include? enum
end

#has_enums ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/has_enum/class_methods.rb', line 15

def has_enums
  columns_hash.each do | column_name, column |
    if human_attribute_name("#{column_name}_enum", :count => nil).is_a? Hash
      if column.type == :text
        has_enum column_name, :multiple => true
      else
        has_enum column_name
      end
    end
  end if table_exists?
end

#has_multiple_enum?(enum) ⇒ Boolean

Returns:

  • (Boolean) 


11
12
13
 
# File 'lib/has_enum/class_methods.rb', line 11

def has_multiple_enum?(enum)
  has_enum?(enum) && serialized_attributes[enum.to_s].try(:object_class) == Array
end

#human_enum_values(enum) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
 
# File 'lib/has_enum/class_methods.rb', line 106

def human_enum_values(enum)
  values = human_attribute_name("#{enum}_enum", :count => nil)
  unless values.is_a? Hash
    values = (enums[enum] || []).inject({}) do |hash, value|
      hash[value] = value.humanize
      hash
    end
  end
  values.with_indifferent_access
end

#human_enums ⇒ Object 



99
100
101
102
103
104
 
# File 'lib/has_enum/class_methods.rb', line 99

def human_enums
  @human_enums ||= enums.keys.inject HashWithIndifferentAccess.new do | hash, enum |
    hash[enum] = human_enum_values enum
    hash
  end
end

#values_for_select_tag(enum) ⇒ Object 



118
119
120
 
# File 'lib/has_enum/class_methods.rb', line 118

def values_for_select_tag(enum)
  (human_enums[enum] || human_enum_values(enum)).invert.to_a
end