activeldap 0.9.0

data/lib/active_ldap/validations.rb

@@ -0,0 +1,171 @@
+require 'active_record/validations'
+
+module ActiveLdap
+  module Validations
+    def self.append_features(base)
+      super
+
+      base.class_eval do
+        alias_method :new_record?, :new_entry?
+        class << self
+          alias_method :human_attribute_name_active_ldap,
+                       :human_attribute_name
+        end
+        include ActiveRecord::Validations
+        class << self
+          alias_method :human_attribute_name,
+                       :human_attribute_name_active_ldap
+          unless method_defined?(:human_attribute_name_with_gettext)
+            def human_attribute_name_with_gettext(attribute_key_name)
+              s_("#{self}|#{attribute_key_name.humanize}")
+            end
+          end
+        end
+
+        # Workaround for GetText's ugly implementation
+        begin
+          instance_method(:save_without_validation)
+        rescue NameError
+          alias_method_chain :save, :validation
+          alias_method_chain :save!, :validation
+          alias_method_chain :update_attribute, :validation_skipping
+        end
+
+        validate_on_create :validate_duplicated_dn_creation
+        validate :validate_required_ldap_values
+        validate :validate_ldap_values
+
+        class << self
+          def evaluate_condition_with_active_ldap_support(condition, entry)
+            evaluate_condition_without_active_ldap_support(condition, entry)
+          rescue ActiveRecord::ActiveRecordError
+            raise Error, $!.message
+          end
+          alias_method_chain :evaluate_condition, :active_ldap_support
+        end
+
+        def save_with_active_ldap_support!
+          save_without_active_ldap_support!
+        rescue ActiveRecord::RecordInvalid
+          raise EntryInvalid, $!.message
+        end
+        alias_method_chain :save!, :active_ldap_support
+
+        def valid?
+          ensure_apply_object_class
+          super
+        end
+
+        private
+        def run_validations_with_active_ldap_support(validation_method)
+          run_validations_without_active_ldap_support(validation_method)
+        rescue ActiveRecord::ActiveRecordError
+          raise Error, $!.message
+        end
+        alias_method_chain :run_validations, :active_ldap_support
+      end
+    end
+
+    private
+    def validate_duplicated_dn_creation
+      if id and exist?
+        if ActiveLdap.get_text_supported?
+          format = _("%{fn} is duplicated: %s")
+        else
+          format = _("is duplicated: %s")
+        end
+        errors.add("dn", format % dn)
+      end
+    end
+
+    # validate_required_ldap_values
+    #
+    # Basic validation:
+    # - Verify that every 'MUST' specified in the schema has a value defined
+    def validate_required_ldap_values
+      # Make sure all MUST attributes have a value
+      @object_classes.each do |object_class|
+        object_class.must.each do |required_attribute|
+          # Normalize to ensure we catch schema problems
+          # needed?
+          real_name = to_real_attribute_name(required_attribute.name, true)
+          raise UnknownAttribute.new(required_attribute) if real_name.nil?
+          # # Set default if it wasn't yet set.
+          # @data[real_name] ||= [] # need?
+          value = @data[real_name] || []
+          # Check for missing requirements.
+          if value.empty?
+            _schema = schema
+            aliases = required_attribute.aliases.collect do |name|
+              self.class.human_attribute_name(name)
+            end
+            args = [self.class.human_object_class_name(object_class)]
+            if ActiveLdap.get_text_supported?
+              if aliases.empty?
+                format = _("%{fn} is required attribute by objectClass '%s'")
+              else
+                format = _("%{fn} is required attribute by objectClass " \
+                           "'%s': aliases: %s")
+                args << aliases.join(', ')
+              end
+            else
+              if aliases.empty?
+                format = "is required attribute by objectClass '%s'"
+              else
+                format = "is required attribute by objectClass '%s'" \
+                         ": aliases: %s"
+                args << aliases.join(', ')
+              end
+            end
+            errors.add(real_name, format % args)
+          end
+        end
+      end
+    end
+
+    def validate_ldap_values
+      @attribute_schemata.each do |name, attribute|
+        self[name, true].each do |value|
+          validate_ldap_value(attribute, name, value)
+        end
+      end
+    end
+
+    def validate_ldap_value(attribute, name, value, option=nil)
+      case value
+      when Hash
+        value.each do |sub_option, val|
+          validate_ldap_value(attribute, name, val,
+                              [option, sub_option].compact.join(";"))
+        end
+      when Array
+        value.each do |val|
+          validate_ldap_value(attribute, name, val, option)
+        end
+      else
+        failed_reason = attribute.validate(value)
+        if failed_reason
+          params = [value,
+                    self.class.human_syntax_description(attribute.syntax),
+                    failed_reason]
+          if ActiveLdap.get_text_supported?
+            if option
+              format =
+                _("%{fn} (%s) has invalid format: %s: required syntax: %s: %s")
+            else
+              format = _("%{fn} has invalid format: %s: required syntax: %s: %s")
+            end
+          else
+            if option
+              format = _("(%s) has invalid format: %s: required syntax: %s: %s")
+            else
+              format = _("has invalid format: %s: required syntax: %s: %s")
+            end
+          end
+          params.unshift(option) if option
+          errors.add(name, format % params)
+        end
+      end
+    end
+  end
+end