activeldap3 1.2.3

data/lib/active_ldap/distinguished_name.rb

@@ -0,0 +1,291 @@
+require 'strscan'
+
+module ActiveLdap
+  class DistinguishedName
+    include GetTextSupport
+
+    class Parser
+      include GetTextSupport
+
+      attr_reader :dn
+      def initialize(source)
+        @dn = nil
+        source = source.to_s if source.is_a?(DN)
+        unless source.is_a?(String)
+          raise DistinguishedNameInputInvalid.new(source)
+        end
+        @source = source
+      end
+
+      def parse
+        return @dn if @dn
+
+        rdns = []
+        scanner = StringScanner.new(@source)
+
+        scanner.scan(/\s*/)
+        raise rdn_is_missing if scanner.scan(/\s*\+\s*/)
+        raise name_component_is_missing if scanner.scan(/\s*,\s*/)
+
+        rdn = {}
+        until scanner.eos?
+          type = scan_attribute_type(scanner)
+          skip_attribute_type_and_value_separator(scanner)
+          value = scan_attribute_value(scanner)
+          rdn[type] = value
+          if scanner.scan(/\s*\+\s*/)
+            raise rdn_is_missing if scanner.eos?
+          elsif scanner.scan(/\s*\,\s*/)
+            rdns << rdn
+            rdn = {}
+            raise name_component_is_missing if scanner.eos?
+          else
+            scanner.scan(/\s*/)
+            rdns << rdn if scanner.eos?
+          end
+        end
+
+        @dn = DN.new(*rdns)
+        @dn
+      end
+
+      private
+      ATTRIBUTE_TYPE_RE = /\s*([a-zA-Z][a-zA-Z\d\-]*|\d+(?:\.\d+)*)\s*/
+      def scan_attribute_type(scanner)
+        raise attribute_type_is_missing unless scanner.scan(ATTRIBUTE_TYPE_RE)
+        scanner[1]
+      end
+
+      def skip_attribute_type_and_value_separator(scanner)
+        raise attribute_value_is_missing unless scanner.scan(/\s*=\s*/)
+      end
+
+      HEX_PAIR = "(?:[\\da-fA-F]{2})"
+      STRING_CHARS_RE = /[^,=\+<>\#;\\\"]*/ #
+      PAIR_RE = /\\([,=\+<>\#;]|\\|\"|(#{HEX_PAIR}))/ #
+      HEX_STRING_RE = /\#(#{HEX_PAIR}+)/ #
+      def scan_attribute_value(scanner)
+        if scanner.scan(HEX_STRING_RE)
+          value = scanner[1].scan(/../).collect do |hex_pair|
+            hex_pair.hex
+          end.pack("C*")
+        elsif scanner.scan(/\"/)
+          value = scan_quoted_attribute_value(scanner)
+        else
+          value = scan_not_quoted_attribute_value(scanner)
+        end
+        raise attribute_value_is_missing if value.blank?
+
+        value
+      end
+
+      def scan_quoted_attribute_value(scanner)
+        result = ""
+        until scanner.scan(/\"/)
+          scanner.scan(/([^\\\"]*)/)
+          quoted_strings = scanner[1]
+          pairs = collect_pairs(scanner)
+
+          if scanner.eos? or (quoted_strings.empty? and pairs.empty?)
+            raise found_unmatched_quotation
+          end
+
+          result << quoted_strings
+          result << pairs
+        end
+        result
+      end
+
+      def scan_not_quoted_attribute_value(scanner)
+        result = ""
+        until scanner.eos?
+          prev_size = result.size
+          pairs = collect_pairs(scanner)
+          strings = scanner.scan(STRING_CHARS_RE)
+          result << pairs if !pairs.nil? and !pairs.empty?
+          unless strings.nil?
+            if scanner.peek(1) == ","
+              result << strings.rstrip
+            else
+              result << strings
+            end
+          end
+          break if prev_size == result.size
+        end
+        result
+      end
+
+      def collect_pairs(scanner)
+        result = ""
+        while scanner.scan(PAIR_RE)
+          if scanner[2]
+            result << [scanner[2].hex].pack("C*")
+          else
+            result << scanner[1]
+          end
+        end
+        result.force_encoding("utf-8") if result.respond_to?(:force_encoding)
+        result
+      end
+
+      def invalid_dn(reason)
+        DistinguishedNameInvalid.new(@source, reason)
+      end
+
+      def name_component_is_missing
+        invalid_dn(_("name component is missing"))
+      end
+
+      def rdn_is_missing
+        invalid_dn(_("relative distinguished name (RDN) is missing"))
+      end
+
+      def attribute_type_is_missing
+        invalid_dn(_("attribute type is missing"))
+      end
+
+      def attribute_value_is_missing
+        invalid_dn(_("attribute value is missing"))
+      end
+
+      def found_unmatched_quotation
+        invalid_dn(_("found unmatched quotation"))
+      end
+    end
+
+    class << self
+      def parse(source)
+        Parser.new(source).parse
+      end
+
+      def escape_value(value)
+        if /(\A | \z)/.match(value)
+          '"' + value.gsub(/([\\\"])/, '\\\\\1') + '"'
+        else
+          value.gsub(/([,=\+<>#;\\\"])/, '\\\\\1')
+        end
+      end
+    end
+
+    attr_reader :rdns
+    def initialize(*rdns)
+      @rdns = rdns.collect do |rdn|
+        if rdn.is_a?(Array) and rdn.size == 2
+          {rdn[0] => rdn[1]}
+        else
+          rdn
+        end
+      end
+    end
+
+    def blank?
+      @rdns.blank?
+    end
+
+    def +(other)
+      self.class.new(*(@rdns + other.rdns))
+    end
+
+    def -(other)
+      rdns = @rdns.dup
+      normalized_rdns = normalize(@rdns)
+      normalize(other.rdns).reverse_each do |rdn|
+        if rdn == normalized_rdns.pop
+          rdns.pop
+        else
+          raise ArgumentError, _("%s isn't sub DN of %s") % [other, self]
+        end
+      end
+      self.class.new(*rdns)
+    end
+
+    def <<(rdn)
+      @rdns << rdn
+      self
+    end
+
+    def unshift(rdn)
+      @rdns.unshift(rdn)
+    end
+
+    def parent
+      return nil if @rdns.size <= 1
+      self.class.new(*@rdns[1..-1])
+    end
+
+    def <=>(other)
+      other = DN.parse(other) if other.is_a?(String)
+      return nil unless other.is_a?(self.class)
+      normalize_for_comparing(@rdns) <=>
+        normalize_for_comparing(other.rdns)
+    end
+
+    def ==(other)
+      case other
+      when self.class
+        normalize(@rdns) == normalize(other.rdns)
+      when String
+        parsed_other = nil
+        begin
+          parsed_other = self.class.parse(other)
+        rescue DistinguishedNameInvalid
+          return false
+        end
+        self == parsed_other
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) and
+        normalize(@rdns).to_s.eql?(normalize(other.rdns).to_s)
+    end
+
+    def hash
+      normalize(@rdns).to_s.hash
+    end
+
+    def to_s
+      klass = self.class
+      @rdns.collect do |rdn|
+        rdn.sort_by do |type, value|
+          type.upcase
+        end.collect do |type, value|
+          "#{type}=#{klass.escape_value(value)}"
+        end.join("+")
+      end.join(",")
+    end
+
+    def to_str # for backward compatibility
+      to_s
+    end
+
+    def to_human_readable_format
+      to_s.inspect
+    end
+
+    private
+    def normalize(rdns)
+      rdns.collect do |rdn|
+        normalized_rdn = {}
+        rdn.each do |key, value|
+          normalized_rdn[key.upcase] = value.upcase
+        end
+        normalized_rdn
+      end
+    end
+
+    def normalize_for_comparing(rdns)
+      normalize(rdns).collect do |rdn|
+        rdn.sort_by do |key, value|
+          key
+        end
+      end.collect do |key, value|
+        [key, value]
+      end
+    end
+  end
+
+  DN = DistinguishedName
+end

data/lib/active_ldap/entry_attribute.rb

@@ -0,0 +1,78 @@
+require "active_ldap/attributes"
+
+module ActiveLdap
+  class EntryAttribute
+    include Attributes::Normalizable
+
+    attr_reader :must, :may, :object_classes, :schemata
+    def initialize(schema, object_classes)
+      @schemata = {}
+      @names = {}
+      @normalized_names = {}
+      @aliases = {}
+      @must = []
+      @may = []
+      @object_classes = []
+      register(schema.attribute('objectClass'))
+      object_classes.each do |objc|
+        # get all attributes for the class
+        object_class = schema.object_class(objc)
+        @object_classes << object_class
+        @must.concat(object_class.must)
+        @may.concat(object_class.may)
+      end
+      @must.uniq!
+      @may.uniq!
+      (@must + @may).each do |attr|
+        # Update attr_method with appropriate
+        register(attr)
+      end
+    end
+
+    def names(normalize=false)
+      names = @names.keys
+      if normalize
+        names.collect do |name|
+          normalize(name)
+        end.uniq
+      else
+        names
+      end
+    end
+
+    def normalize(name, allow_normalized_name=false)
+      return name if name.nil?
+      return nil if @names.empty? and @aliases.empty?
+      name = name.to_s
+      real_name = @names[name]
+      real_name ||= @aliases[name.underscore]
+      if real_name
+        real_name
+      elsif allow_normalized_name
+        return nil if @normalized_names.empty?
+        @normalized_names[normalize_attribute_name(name)]
+      else
+        nil
+      end
+    end
+
+    def all_names
+      @names.keys + @aliases.keys
+    end
+
+    # register
+    #
+    # Make a method entry for _every_ alias of a valid attribute and map it
+    # onto the first attribute passed in.
+    def register(attribute)
+      real_name = attribute.name
+      return if @schemata.has_key?(real_name)
+      @schemata[real_name] = attribute
+      ([real_name] + attribute.aliases).each do |name|
+        @names[name] = real_name
+        @aliases[name.underscore] = real_name
+        @normalized_names[normalize_attribute_name(name)] = real_name
+      end
+    end
+  end
+end

data/lib/active_ldap/escape.rb

@@ -0,0 +1,12 @@
+module ActiveLdap
+  module Escape
+    module_function
+    def ldap_filter_escape(str)
+      str.to_s.gsub(/\*/, "**")
+    end
+
+    def ldap_filter_unescape(str)
+      str.to_s.gsub(/\*\*/, "*")
+    end
+  end
+end

data/lib/active_ldap/get_text.rb

@@ -0,0 +1,9 @@
+if Object.const_defined?(:FastGettext)
+  ActiveLdap.const_set("GetText", FastGettext)
+end
+
+unless ActiveLdap.const_defined?(:GetText)
+  require 'active_ldap/get_text_fallback'
+end
+
+require 'active_ldap/get_text_support'

data/lib/active_ldap/get_text/parser.rb

@@ -0,0 +1,161 @@
+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.setup_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'
+            erb = ERB.new(File.read(configuration))
+            erb.filename = configuration
+            configuration = YAML.load(erb.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