# File lib/active_ldap/validations.rb, line 5
 5:     def self.append_features(base)
 6:       super
 7: 
 8:       base.class_eval do
 9:         alias_method :new_record?, :new_entry?
10:         class << self
11:           alias_method :human_attribute_name_active_ldap,
12:                        :human_attribute_name
13:         end
14:         include ActiveRecord::Validations
15:         class << self
16:           alias_method :human_attribute_name,
17:                        :human_attribute_name_active_ldap
18:           unless method_defined?(:human_attribute_name_with_gettext)
19:             def human_attribute_name_with_gettext(attribute_key_name)
20:               s_("#{self}|#{attribute_key_name.humanize}")
21:             end
22:           end
23:         end
24: 
25:         # Workaround for GetText's ugly implementation
26:         begin
27:           instance_method(:save_without_validation)
28:         rescue NameError
29:           alias_method_chain :save, :validation
30:           alias_method_chain :save!, :validation
31:           alias_method_chain :update_attribute, :validation_skipping
32:         end
33: 
34:         validate_on_create :validate_duplicated_dn_creation
35:         validate :validate_required_ldap_values
36:         validate :validate_ldap_values
37: 
38:         class << self
39:           def evaluate_condition_with_active_ldap_support(condition, entry)
40:             evaluate_condition_without_active_ldap_support(condition, entry)
41:           rescue ActiveRecord::ActiveRecordError
42:             raise Error, $!.message
43:           end
44:           alias_method_chain :evaluate_condition, :active_ldap_support
45:         end
46: 
47:         def save_with_active_ldap_support!
48:           save_without_active_ldap_support!
49:         rescue ActiveRecord::RecordInvalid
50:           raise EntryInvalid, $!.message
51:         end
52:         alias_method_chain :save!, :active_ldap_support
53: 
54:         def valid?
55:           ensure_apply_object_class
56:           super
57:         end
58: 
59:         private
60:         def run_validations_with_active_ldap_support(validation_method)
61:           run_validations_without_active_ldap_support(validation_method)
62:         rescue ActiveRecord::ActiveRecordError
63:           raise Error, $!.message
64:         end
65:         alias_method_chain :run_validations, :active_ldap_support
66:       end
67:     end

    # File lib/active_ldap/validations.rb, line 39
39:           def evaluate_condition_with_active_ldap_support(condition, entry)
40:             evaluate_condition_without_active_ldap_support(condition, entry)
41:           rescue ActiveRecord::ActiveRecordError
42:             raise Error, $!.message
43:           end

    # File lib/active_ldap/validations.rb, line 19
19:             def human_attribute_name_with_gettext(attribute_key_name)
20:               s_("#{self}|#{attribute_key_name.humanize}")
21:             end

    # File lib/active_ldap/validations.rb, line 60
60:         def run_validations_with_active_ldap_support(validation_method)
61:           run_validations_without_active_ldap_support(validation_method)
62:         rescue ActiveRecord::ActiveRecordError
63:           raise Error, $!.message
64:         end

    # File lib/active_ldap/validations.rb, line 47
47:         def save_with_active_ldap_support!
48:           save_without_active_ldap_support!
49:         rescue ActiveRecord::RecordInvalid
50:           raise EntryInvalid, $!.message
51:         end

    # File lib/active_ldap/validations.rb, line 54
54:         def valid?
55:           ensure_apply_object_class
56:           super
57:         end

    # File lib/active_ldap/validations.rb, line 70
70:     def validate_duplicated_dn_creation
71:       if id and exist?
72:         if ActiveLdap.get_text_supported?
73:           format = _("%{fn} is duplicated: %s")
74:         else
75:           format = _("is duplicated: %s")
76:         end
77:         errors.add("dn", format % dn)
78:       end
79:     end

     # File lib/active_ldap/validations.rb, line 134
134:     def validate_ldap_value(attribute, name, value, option=nil)
135:       case value
136:       when Hash
137:         value.each do |sub_option, val|
138:           validate_ldap_value(attribute, name, val,
139:                               [option, sub_option].compact.join(";"))
140:         end
141:       when Array
142:         value.each do |val|
143:           validate_ldap_value(attribute, name, val, option)
144:         end
145:       else
146:         failed_reason = attribute.validate(value)
147:         if failed_reason
148:           params = [value,
149:                     self.class.human_syntax_description(attribute.syntax),
150:                     failed_reason]
151:           if ActiveLdap.get_text_supported?
152:             if option
153:               format =
154:                 _("%{fn} (%s) has invalid format: %s: required syntax: %s: %s")
155:             else
156:               format = _("%{fn} has invalid format: %s: required syntax: %s: %s")
157:             end
158:           else
159:             if option
160:               format = _("(%s) has invalid format: %s: required syntax: %s: %s")
161:             else
162:               format = _("has invalid format: %s: required syntax: %s: %s")
163:             end
164:           end
165:           params.unshift(option) if option
166:           errors.add(name, format % params)
167:         end
168:       end
169:     end

     # File lib/active_ldap/validations.rb, line 126
126:     def validate_ldap_values
127:       @attribute_schemata.each do |name, attribute|
128:         self[name, true].each do |value|
129:           validate_ldap_value(attribute, name, value)
130:         end
131:       end
132:     end

     # File lib/active_ldap/validations.rb, line 85
 85:     def validate_required_ldap_values
 86:       # Make sure all MUST attributes have a value
 87:       @object_classes.each do |object_class|
 88:         object_class.must.each do |required_attribute|
 89:           # Normalize to ensure we catch schema problems
 90:           # needed?
 91:           real_name = to_real_attribute_name(required_attribute.name, true)
 92:           raise UnknownAttribute.new(required_attribute) if real_name.nil?
 93:           # # Set default if it wasn't yet set.
 94:           # @data[real_name] ||= [] # need?
 95:           value = @data[real_name] || []
 96:           # Check for missing requirements.
 97:           if value.empty?
 98:             _schema = schema
 99:             aliases = required_attribute.aliases.collect do |name|
100:               self.class.human_attribute_name(name)
101:             end
102:             args = [self.class.human_object_class_name(object_class)]
103:             if ActiveLdap.get_text_supported?
104:               if aliases.empty?
105:                 format = _("%{fn} is required attribute by objectClass '%s'")
106:               else
107:                 format = _("%{fn} is required attribute by objectClass " \
108:                            "'%s': aliases: %s")
109:                 args << aliases.join(', ')
110:               end
111:             else
112:               if aliases.empty?
113:                 format = "is required attribute by objectClass '%s'"
114:               else
115:                 format = "is required attribute by objectClass '%s'" \
116:                          ": aliases: %s"
117:                 args << aliases.join(', ')
118:               end
119:             end
120:             errors.add(real_name, format % args)
121:           end
122:         end
123:       end
124:     end