activeldap 0.9.0

data/lib/active_ldap/get_text/parser.rb

@@ -0,0 +1,159 @@
+require 'active_ldap'
+require 'gettext/parser/ruby'
+
+module ActiveLdap
+  module GetText
+    class Parser
+      include GetText
+
+      def initialize(configuration=nil)
+        configuration = ensure_configuration(configuration)
+        configuration = default_configuration.merge(configuration)
+
+        configuration = extract_options(configuration)
+        ActiveLdap::Base.establish_connection(configuration)
+      end
+
+      def parse(file, targets=[])
+        targets = RubyParser.parse(file, targets) if RubyParser.target?(file)
+        extract(targets) do
+          load_constants(file).each do |name|
+            klass = name.constantize
+            next unless klass.is_a?(Class)
+            next unless klass < ActiveLdap::Base
+            register(klass.name.singularize.underscore.gsub(/_/, " "), file)
+            next unless @extract_schema
+            klass.classes.each do |object_class|
+              register_object_class(object_class, file)
+            end
+          end
+        end
+      end
+
+      def target?(file)
+        @classes_re.match(File.read(file))
+      end
+
+      def extract_all_in_schema(targets=[])
+        extract(targets) do
+          schema = ActiveLdap::Base.schema
+          schema.object_classes.each do |object_class|
+            register_object_class(object_class, "-")
+          end
+          schema.attributes.each do |attribute|
+            register_attribute(attribute, "-")
+          end
+          schema.ldap_syntaxes.each do |syntax|
+            register_syntax(syntax, "-")
+          end
+        end
+      end
+
+      private
+      def extract_options(configuration)
+        configuration = configuration.dup
+        classes = configuration.delete(:classes) || ["ActiveLdap::Base"]
+        @classes_re = /class.*#{Regexp.union(*classes)}/ #
+        @extract_schema = configuration.delete(:extract_schema)
+        configuration
+      end
+
+      def default_configuration
+        {
+          :host => "127.0.0.1",
+          :allow_anonymous => true,
+          :extract_schema => false,
+        }
+      end
+
+      def ensure_configuration(configuration)
+        configuration ||= ENV["RAILS_ENV"] || {}
+        if configuration.is_a?(String)
+          if File.exists?(configuration)
+            require 'erb'
+            require 'yaml'
+            configuration = YAML.load(ERB.new(File.read(configuration)).result)
+          else
+            ENV["RAILS_ENV"] = configuration
+            require 'config/environment'
+            configuration = ActiveLdap::Base.configurations[configuration]
+          end
+        end
+        if Object.const_defined?(:RAILS_ENV)
+          rails_configuration = ActiveLdap::Base.configurations[RAILS_ENV]
+          configuration = rails_configuration.merge(configuration)
+        end
+        configuration = configuration.symbolize_keys
+      end
+
+      def load_constants(file)
+        old_constants = Object.constants
+        begin
+          eval(File.read(file), TOPLEVEL_BINDING, file)
+        rescue
+          format = _("Ignored '%{file}'. Solve dependencies first.")
+          $stderr.puts(format % {:file => file})
+          $stderr.puts($!)
+        end
+        Object.constants - old_constants
+      end
+
+      def extract(targets)
+        @targets = {}
+        targets.each do |id, *file_infos|
+          @targets[id] = file_infos
+        end
+        yield
+        @targets.collect do |id, file_infos|
+          [id, *file_infos.uniq]
+        end.sort_by do |id,|
+          id
+        end
+      end
+
+      def register(id, file)
+        file_info = "#{file}:-"
+        @targets[id] ||= []
+        @targets[id] << file_info
+      end
+
+      def register_object_class(object_class, file)
+        [object_class.name, *object_class.aliases].each do |name|
+          register(ActiveLdap::Base.human_object_class_name_msgid(name), file)
+        end
+        if object_class.description
+          msgid =
+            ActiveLdap::Base.human_object_class_description_msgid(object_class)
+          register(msgid, file)
+        end
+        (object_class.must(false) + object_class.may(false)).each do |attribute|
+          register_attribute(attribute, file)
+        end
+        object_class.super_classes.each do |super_class|
+          register_object_class(super_class, file)
+        end
+      end
+
+      def register_attribute(attribute, file)
+        [attribute.name, *attribute.aliases].each do |name|
+          msgid = ActiveLdap::Base.human_attribute_name_msgid(name)
+          register(msgid, file) if msgid
+        end
+        if attribute.description
+          msgid = ActiveLdap::Base.human_attribute_description_msgid(attribute)
+          register(msgid, file)
+        end
+      end
+
+      def register_syntax(syntax, file)
+        msgid = ActiveLdap::Base.human_syntax_name_msgid(syntax)
+        register(msgid, file)
+
+        if syntax.description
+          msgid = ActiveLdap::Base.human_syntax_description_msgid(syntax)
+          register(msgid, file)
+        end
+      end
+    end
+  end
+end

data/lib/active_ldap/get_text.rb

@@ -0,0 +1,8 @@
+begin
+  require "gettext/active_record"
+  ActiveLdap.const_set("GetText", GetText)
+rescue LoadError
+  require 'active_ldap/get_text_fallback'
+end
+
+require 'active_ldap/get_text_support'

data/lib/active_ldap/get_text_fallback.rb

@@ -0,0 +1,53 @@
+module ActiveLdap
+  module GetTextFallback
+    class << self
+      def included(base)
+        base.extend(self)
+      end
+    end
+
+    module_function
+    def bindtextdomain(domain_name, *args)
+    end
+
+    def gettext(msg_id)
+      msg_id
+    end
+
+    def ngettext(arg1, arg2, arg3=nil)
+      if arg1.kind_of?(Array)
+        msg_id = arg1[0]
+        msg_id_plural = arg1[1]
+        n = arg2
+      else
+        msg_id = arg1
+        msg_id_plural = arg2
+        n = arg3
+      end
+      n == 1 ? msg_id : msg_id_plural
+    end
+
+    def N_(msg_id)
+      msg_id
+    end
+
+    def Nn_(msg_id, msg_id_plural)
+      [msg_id, msg_id_plural]
+    end
+
+    def sgettext(msg_id, div='|')
+      index = msg_id.rindex(div)
+      if index
+        msg_id[(index + 1)..-1]
+      else
+        msg_id
+      end
+    end
+
+    alias_method(:_, :gettext)
+    alias_method(:n_, :ngettext)
+    alias_method(:s_, :sgettext)
+  end
+
+  GetText = GetTextFallback
+end

data/lib/active_ldap/get_text_support.rb

@@ -0,0 +1,26 @@
+module ActiveLdap
+  if const_defined?(:GetTextFallback)
+    class << self
+      def get_text_supported?
+        false
+      end
+    end
+  else
+    class << self
+      def get_text_supported?
+        true
+      end
+    end
+  end
+
+  module GetTextSupport
+    class << self
+      def included(base)
+        base.class_eval do
+          include(GetText)
+          bindtextdomain("active-ldap")
+        end
+      end
+    end
+  end
+end

data/lib/active_ldap/helper.rb

@@ -0,0 +1,33 @@
+module ActiveLdap
+  module Helper
+    def ldap_attribute_name_gettext(attribute)
+      Base.human_attribute_name(attribute)
+    end
+    alias_method(:la_, :ldap_attribute_name_gettext)
+
+    def ldap_attribute_description_gettext(attribute)
+      Base.human_attribute_description(attribute)
+    end
+    alias_method(:lad_, :ldap_attribute_description_gettext)
+
+    def ldap_object_class_name_gettext(object_class)
+      Base.human_object_class_name(object_class)
+    end
+    alias_method(:loc_, :ldap_object_class_name_gettext)
+
+    def ldap_object_class_description_gettext(object_class)
+      Base.human_object_class_description(object_class)
+    end
+    alias_method(:locd_, :ldap_object_class_description_gettext)
+
+    def ldap_syntax_name_gettext(syntax)
+      Base.human_syntax_name(syntax)
+    end
+    alias_method(:ls_, :ldap_syntax_name_gettext)
+
+    def ldap_syntax_description_gettext(syntax)
+      Base.human_syntax_description(syntax)
+    end
+    alias_method(:lsd_, :ldap_syntax_description_gettext)
+  end
+end

data/lib/active_ldap/human_readable.rb

@@ -0,0 +1,112 @@
+module ActiveLdap
+  module HumanReadable
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def human_attribute_name(attribute_or_name)
+        msgid = human_attribute_name_msgid(attribute_or_name)
+        msgid ||= human_attribute_name_with_gettext(attribute_or_name)
+        s_(msgid)
+      end
+
+      def human_attribute_name_msgid(attribute_or_name)
+        if attribute_or_name.is_a?(Schema::Attribute)
+          name = attribute_or_name.name
+        else
+          attribute = schema.attribute(attribute_or_name)
+          return nil if attribute.id.nil?
+          if attribute.name == attribute_or_name or
+              attribute.aliases.include?(attribute_or_name)
+            name = attribute_or_name
+          else
+            return nil
+          end
+        end
+        "LDAP|Attribute|#{name}"
+      end
+
+      def human_attribute_description(attribute_or_name)
+        msgid = human_attribute_description_msgid(attribute_or_name)
+        return nil if msgid.nil?
+        s_(msgid)
+      end
+
+      def human_attribute_description_msgid(attribute_or_name)
+        if attribute_or_name.is_a?(Schema::Attribute)
+          attribute = attribute_or_name
+        else
+          attribute = schema.attribute(attribute_or_name)
+          return nil if attribute.nil?
+        end
+        description = attribute.description
+        return nil if description.nil?
+        "LDAP|Description|Attribute|#{attribute.name}|#{description}"
+      end
+
+      def human_object_class_name(object_class_or_name)
+        s_(human_object_class_name_msgid(object_class_or_name))
+      end
+
+      def human_object_class_name_msgid(object_class_or_name)
+        if object_class_or_name.is_a?(Schema::ObjectClass)
+          name = object_class_or_name.name
+        else
+          name = object_class_or_name
+        end
+        "LDAP|ObjectClass|#{name}"
+      end
+
+      def human_object_class_description(object_class_or_name)
+        msgid = human_object_class_description_msgid(object_class_or_name)
+        return nil if msgid.nil?
+        s_(msgid)
+      end
+
+      def human_object_class_description_msgid(object_class_or_name)
+        if object_class_or_name.is_a?(Schema::ObjectClass)
+          object_class = object_class_or_name
+        else
+          object_class = schema.object_class(object_class_or_name)
+          return nil if object_class.nil?
+        end
+        description = object_class.description
+        return nil if description.nil?
+        "LDAP|Description|ObjectClass|#{object_class.name}|#{description}"
+      end
+
+      def human_syntax_name(syntax_or_id)
+        s_(human_syntax_name_msgid(syntax_or_id))
+      end
+
+      def human_syntax_name_msgid(syntax_or_id)
+        if syntax_or_id.is_a?(Schema::Syntax)
+          id = syntax_or_id.id
+        else
+          id = syntax_or_id
+        end
+        "LDAP|Syntax|#{id}"
+      end
+
+      def human_syntax_description(syntax_or_id)
+        msgid = human_syntax_description_msgid(syntax_or_id)
+        return nil if msgid.nil?
+        s_(msgid)
+      end
+
+      def human_syntax_description_msgid(syntax_or_id)
+        if syntax_or_id.is_a?(Schema::Syntax)
+          syntax = syntax_or_id
+        else
+          syntax = schema.ldap_syntax(syntax_or_id)
+          return nil if syntax.nil?
+        end
+        description = syntax.description
+        return nil if description.nil?
+        "LDAP|Description|Syntax|#{syntax.id}|#{description}"
+      end
+    end
+  end
+end

data/lib/active_ldap/ldap_error.rb

@@ -0,0 +1,74 @@
+module ActiveLdap
+  class LdapError < Error
+    class << self
+      def define(code, name, target)
+        klass_name = name.downcase.camelize
+        target.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+          class #{klass_name} < #{self}
+            CODE = #{code}
+            def code
+              CODE
+            end
+          end
+EOC
+        target.const_get(klass_name)
+      end
+    end
+
+    ERRORS = {}
+    {
+      0x00 => "SUCCESS",
+      0x01 => "OPERATIONS_ERROR",
+      0x02 => "PROTOCOL_ERROR",
+      0x03 => "TIMELIMIT_EXCEEDED",
+      0x04 => "SIZELIMIT_EXCEEDED",
+      0x05 => "COMPARE_FALSE",
+      0x06 => "COMPARE_TRUE",
+      0x07 => "AUTH_METHOD_NOT_SUPPORTED",
+      0x08 => "STRONG_AUTH_REQUIRED",
+      0x09 => "PARTIAL_RESULTS", # LDAPv2+ (not LDAPv3)
+
+      0x0a => "REFERRAL",
+      0x0b => "ADMINLIMIT_EXCEEDED",
+      0x0c => "UNAVAILABLE_CRITICAL_EXTENSION",
+      0x0d => "CONFIDENTIALITY_REQUIRED",
+      0x0e => "LDAP_SASL_BIND_IN_PROGRESS",
+
+      0x10 => "NO_SUCH_ATTRIBUTE",
+      0x11 => "UNDEFINED_TYPE",
+      0x12 => "INAPPROPRIATE_MATCHING",
+      0x13 => "CONSTRAINT_VIOLATION",
+      0x14 => "TYPE_OR_VALUE_EXISTS",
+      0x15 => "INVALID_SYNTAX",
+
+      0x20 => "NO_SUCH_OBJECT",
+      0x21 => "ALIAS_PROBLEM",
+      0x22 => "INVALID_DN_SYNTAX",
+      0x23 => "IS_LEAF",
+      0x24 => "ALIAS_DEREF_PROBLEM",
+
+      0x2F => "PROXY_AUTHZ_FAILURE",
+      0x30 => "INAPPROPRIATE_AUTH",
+      0x31 => "INVALID_CREDENTIALS",
+      0x32 => "INSUFFICIENT_ACCESS",
+
+      0x33 => "BUSY",
+      0x34 => "UNAVAILABLE",
+      0x35 => "UNWILLING_TO_PERFORM",
+      0x36 => "LOOP_DETECT",
+
+      0x40 => "NAMING_VIOLATION",
+      0x41 => "OBJECT_CLASS_VIOLATION",
+      0x42 => "NOT_ALLOWED_ON_NONLEAF",
+      0x43 => "NOT_ALLOWED_ON_RDN",
+      0x44 => "ALREADY_EXISTS",
+      0x45 => "NO_OBJECT_CLASS_MODS",
+      0x46 => "RESULTS_TOO_LARGE",
+      0x47 => "AFFECTS_MULTIPLE_DSAS",
+
+      0x50 => "OTHER",
+    }.each do |code, name|
+      ERRORS[code] = LdapError.define(code, name, self)
+    end
+  end
+end

data/lib/active_ldap/ldif.rb

@@ -0,0 +1,52 @@
+# Experimental work-in-progress LDIF implementation.
+# Don't care this file for now.
+
+require 'strscan'
+
+module ActiveLdap
+  class Ldif
+    include GetTextSupport
+
+    class Parser
+      include GetTextSupport
+
+      attr_reader :ldif
+      def initialize(source)
+        @ldif = nil
+        source = source.to_s if source.is_a?(LDIF)
+        @source = source
+      end
+
+      def parse
+        return @ldif if @ldif
+
+        scanner = StringScanner.new(@source)
+        raise version_spec_is_missing unless scanner.scan(/version:\s*(\d+)/)
+
+        version = Integer(scanner[1])
+        raise unsupported_version(version) if version != "1"
+      end
+
+      private
+      def invalid_ldif(reason)
+        LdifInvalid.new(@source, reason)
+      end
+
+      def version_spec_is_missing
+        invalid_ldif(_("version spec is missing"))
+      end
+
+      def unsupported_version(version)
+        invalid_ldif(_("unsupported version: %d") % version)
+      end
+    end
+
+    class << self
+      def parse(ldif)
+        Parser.new(ldif).parse
+      end
+    end
+  end
+
+  LDIF = Ldif
+end

data/lib/active_ldap/object_class.rb

@@ -0,0 +1,93 @@
+module ActiveLdap
+  module ObjectClass
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def classes
+        required_classes.collect do |name|
+          schema.object_class(name)
+        end
+      end
+    end
+
+    def add_class(*target_classes)
+      replace_class((classes + target_classes.flatten).uniq)
+    end
+
+    def ensure_recommended_classes
+      add_class(self.class.recommended_classes)
+    end
+
+    def remove_class(*target_classes)
+      replace_class((classes - target_classes.flatten).uniq)
+    end
+
+    def replace_class(*target_classes)
+      new_classes = target_classes.flatten.uniq
+      assert_object_classes(new_classes)
+      if new_classes.sort != classes.sort
+        set_attribute('objectClass', new_classes)
+      end
+    end
+
+    def classes
+      (get_attribute('objectClass', true) || []).dup
+    end
+
+    private
+    def assert_object_classes(new_classes)
+      assert_valid_object_class_value_type(new_classes)
+      assert_valid_object_class_value(new_classes)
+      assert_have_all_required_classes(new_classes)
+    end
+
+    def assert_valid_object_class_value_type(new_classes)
+      invalid_classes = new_classes.reject do |new_class|
+        new_class.is_a?(String)
+      end
+      unless invalid_classes.empty?
+        format = _("Value in objectClass array is not a String: %s")
+        invalid_classes_info = invalid_classes.collect do |invalid_class|
+          "#{invalid_class.class}:#{invalid_class.inspect}"
+        end.join(", ")
+        raise TypeError, format % invalid_classes_info
+      end
+    end
+
+    def assert_valid_object_class_value(new_classes)
+      _schema = schema
+      invalid_classes = new_classes.reject do |new_class|
+        !_schema.object_class(new_class).id.nil?
+      end
+      unless invalid_classes.empty?
+        format = _("unknown objectClass in LDAP server: %s")
+        message = format % invalid_classes.join(', ')
+        raise ObjectClassError, message
+      end
+    end
+
+    def assert_have_all_required_classes(new_classes)
+      _schema = schema
+      normalized_new_classes = new_classes.collect(&:downcase)
+      required_classes = self.class.required_classes
+      required_classes = required_classes.reject do |required_class_name|
+        normalized_new_classes.include?(required_class_name.downcase) or
+          (normalized_new_classes.find do |new_class|
+             required_class = _schema.object_class(required_class_name)
+             _schema.object_class(new_class).super_class?(required_class)
+           end)
+      end
+      unless required_classes.empty?
+        format = _("Can't remove required objectClass: %s")
+        required_class_names = required_classes.collect do |required_class|
+          required_class = _schema.object_class(required_class)
+          self.class.human_object_class_name(required_class)
+        end
+        message = format % required_class_names.join(", ")
+        raise RequiredObjectClassMissed, message
+      end
+    end
+  end
+end