rom-ldap 0.2.2

data/lib/rom/ldap/directory/vendors/apache_ds.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # Apache Directory Extension
+    #
+    # @api private
+    module ApacheDs
+      # IGNORE_ATTRS_REGEX = /^[m-|ads|entry].*$/.freeze
+
+      # @return [Array]
+      #
+      # @api public
+      def schema_attributes
+        query(base: 'ou=schema', filter: '(objectClass=metaAttributeType)')
+      end
+
+      # @return [Array]
+      #
+      # @api public
+      def schemas_classes
+        query(base: 'ou=schema', filter: '(objectClass=metaObjectClass)')
+      end
+    end
+  end
+end

data/lib/rom/ldap/directory/vendors/e_directory.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # Novell eDirectory Extension
+    #
+    # @api private
+    module EDirectory
+      # WIP
+      def transactions
+        # noop
+      end
+    end
+  end
+end

data/lib/rom/ldap/directory/vendors/open_directory.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # Apple Open Directory Extension
+    #
+    # @api private
+    module OpenDirectory
+    end
+  end
+end

data/lib/rom/ldap/directory/vendors/open_dj.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # OpenDJ Server Extension
+    #
+    # @api private
+    module OpenDj
+      # @return [String]
+      #
+      # @api public
+      def full_vendor_version
+        root.first('fullVendorVersion')
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def etag
+        root.first('etag')
+      end
+    end
+  end
+end

data/lib/rom/ldap/directory/vendors/open_ldap.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # OpenLDAP Extension
+    #
+    # @api private
+    module OpenLdap
+      #
+      # @return [String]
+      #
+      # @api public
+      def vendor_name
+        'OpenLDAP'
+      end
+
+      #
+      # @return [String]
+      #
+      # @api public
+      def vendor_version
+        '0.0'
+      end
+
+      #
+      # @return [String]
+      #
+      # @api public
+      def organization
+        query(base: contexts[0]).first.first('o')
+      end
+    end
+  end
+end

data/lib/rom/ldap/directory/vendors/three_eight_nine.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # RedHat 389DS Extension
+    #
+    # @api private
+    module ThreeEightNine
+      # @api public
+      def netscapemdsuffix
+        root.first('netscapemdsuffix')
+      end
+    end
+  end
+end

data/lib/rom/ldap/directory/vendors/unknown.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    # @api private
+    module Unknown
+      # @return [String]
+      #
+      # @api public
+      def vendor_name
+        'Unknown'
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def vendor_version
+        'Unknown'
+      end
+    end
+  end
+end

data/lib/rom/ldap/dsl.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'concurrent/map'
+require 'rom/support/inflector'
+require 'rom/constants'
+require 'rom/ldap/types'
+
+module ROM
+  module LDAP
+    # @api private
+    class DSL < BasicObject
+
+      # @!attribute [r] schema
+      #   @return [LDAP::Schema]
+      attr_reader :schema
+
+      # @!attribute [r] relations
+      #   @return [Hash, RelationRegistry]
+      attr_reader :relations
+
+      # @!attribute [r] picked_relations
+      #   @return [Concurrent::Map]
+      attr_reader :picked_relations
+
+      # @api private
+      def initialize(schema)
+        @schema = schema
+        @relations = schema.respond_to?(:relations) ? schema.relations : EMPTY_HASH
+        @picked_relations = ::Concurrent::Map.new
+      end
+
+      # @api private
+      def call(&block)
+        result = instance_exec(select_relations(block.parameters), &block)
+
+        if result.is_a?(::Array)
+          result
+        else
+          [result]
+        end
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        super || schema.key?(name)
+      end
+
+      private
+
+      # @api private
+      def type(identifier)
+        type_name = Inflector.classify(identifier)
+        types.const_get(type_name) if types.const_defined?(type_name)
+      end
+
+      # @api private
+      def types
+        ::ROM::LDAP::Types
+      end
+
+      # @api private
+      def select_relations(parameters)
+        @picked_relations.fetch_or_store(parameters.hash) do
+          keys = parameters.select { |type, _| type == :keyreq }
+
+          if keys.empty?
+            relations
+          else
+            keys.each_with_object({}) { |(_, k), rs| rs[k] = relations[k] }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/errors.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    # @see ROM::LDAP::Gateway
+    #
+    # @see ROM::LDAP::Schema::Inferrer
+    #
+    CONNECTION_FAILURES = [
+      EOFError,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::EIO,
+      Errno::ENETDOWN,
+      Errno::ENETRESET,
+      Errno::EPIPE,
+      Errno::ETIMEDOUT,
+      IOError
+    ].freeze
+
+    # @see Client::Authentication#bind
+    #
+    BindError                     = Class.new(StandardError)
+
+    # @see Client::Authentication#sasl_bind
+    #
+    SecureBindError               = Class.new(StandardError)
+
+    # @see Client#submit
+    #
+    ResponseError                 = Class.new(StandardError)
+
+    # @see Directory::Operations#find, #by_dn, #add
+    #
+    DistinguishedNameError        = Class.new(StandardError)
+
+    # @see Socket#connect
+    #
+    ConnectionError               = Class.new(StandardError)
+
+    # @see Directory::Password#generate
+    #
+    PasswordError                 = Class.new(StandardError)
+  end
+end

data/lib/rom/ldap/expression.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    # @api private
+    class Expression
+
+      extend Initializer
+
+      option :op, type: Types::Abstract
+
+      option :field, optional: true, type: Types::Field
+
+      option :value, optional: true, type: Types::Value
+
+      option :exps,  optional: true, type: Types::Array.of(Types.Instance(Expression))
+
+      #
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_ber
+        require 'rom/ldap/expression_encoder'
+        ExpressionEncoder.new(options).call
+      end
+
+      # Unbracketed filter string
+      #
+      # @return [String]
+      #
+      def to_raw_filter
+        case op
+        when :op_eql, :op_bineq then "#{field}=#{value}"
+        when :op_ext  then "#{field}:=#{value}"
+        when :op_gte  then "#{field}>=#{value}"
+        when :op_lte  then "#{field}<=#{value}"
+        when :op_prx  then "#{field}~=#{value}"
+        when :con_and then "&#{exps.map(&:to_filter).join}"
+        when :con_or  then "|#{exps.map(&:to_filter).join}"
+        when :con_not then "!#{exps[0].to_filter}"
+        end
+      end
+
+      # Bracketed filter string
+      #
+      # @return [String]
+      #
+      def to_filter
+        "(#{to_raw_filter})"
+      end
+      alias_method :to_s, :to_filter
+
+      # AST with original atrributes and values
+      #
+      # @return [Array]
+      #
+      def to_ast
+        case op
+        when :con_and then [op, exps.map(&:to_ast)]
+        when :con_or  then [op, exps.map(&:to_ast)]
+        when :con_not then [op, exps[0].to_ast]
+        else
+          [op, field, value]
+        end
+      end
+      alias_method :to_a, :to_ast
+
+      # @return [String]
+      #
+      def inspect
+        %(#<#{self.class} #{to_raw_filter} />)
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/expression_encoder.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    # Used in ROM::LDAP::Expression#to_ber.
+    #
+    #       Filter ::=
+    #           CHOICE {
+    #               and             [0] SET OF Filter,
+    #               or              [1] SET OF Filter,
+    #               not             [2] Filter,
+    #               equalityMatch   [3] AttributeValueAssertion,
+    #               substrings      [4] SubstringFilter,
+    #               greaterOrEqual  [5] AttributeValueAssertion,
+    #               lessOrEqual     [6] AttributeValueAssertion,
+    #               present         [7] AttributeType,
+    #               approxMatch     [8] AttributeValueAssertion,
+    #               extensibleMatch [9] MatchingRuleAssertion
+    #           }
+    #
+    #       SubstringFilter ::=
+    #           SEQUENCE {
+    #               type               AttributeType,
+    #               SEQUENCE OF CHOICE {
+    #                   initial        [0] LDAPString,
+    #                   any            [1] LDAPString,
+    #                   final          [2] LDAPString
+    #               }
+    #           }
+    #
+    #       MatchingRuleAssertion ::=
+    #           SEQUENCE {
+    #             matchingRule    [1] MatchingRuleId OPTIONAL,
+    #             type            [2] AttributeDescription OPTIONAL,
+    #             matchValue      [3] AssertionValue,
+    #             dnAttributes    [4] BOOLEAN DEFAULT FALSE
+    #           }
+    #
+    #       Matching Rule Suffixes
+    #           Less than   [.1] or .[lt]
+    #           Less than or equal to  [.2] or [.lte]
+    #           Equality  [.3] or  [.eq] (default)
+    #           Greater than or equal to  [.4] or [.gte]
+    #           Greater than  [.5] or [.gt]
+    #           Substring  [.6] or  [.sub]
+    #
+    #
+    # @api private
+    class ExpressionEncoder
+
+      using ::BER
+
+      extend Initializer
+
+      option :op, type: Types::Abstract
+
+      option :field, optional: true, type: Types::Field
+      option :value, optional: true, type: Types::Value
+      option :exps,  optional: true, type: Types::Array.of(Types.Instance(LDAP::Expression))
+
+      # @return [BER]
+      #
+      def call
+        case op
+        when :op_eql
+          if value == WILDCARD
+            field.to_s.to_ber_contextspecific(7)
+          elsif /[*]/.match?(value.to_s) # substring
+            substring
+          else
+            to_context(3)
+          end
+        when :op_bineq
+          [
+            field.to_s.to_ber,
+            unescape(value).to_ber_bin
+          ].to_ber_contextspecific(3)
+        when :op_ext
+          extensible
+        when :op_gte
+          to_context(5)
+        when :op_lte
+          to_context(6)
+        when :op_prx
+          to_context(8)
+        when :con_and
+          exps.map(&:to_ber).to_ber_contextspecific(0)
+        when :con_or
+          exps.map(&:to_ber).to_ber_contextspecific(1)
+        when :con_not
+          exps.map(&:to_ber).to_ber_contextspecific(2)
+        end
+      end
+
+      private
+
+      def substring
+        ary = value.split(/[*]+/, -1)
+
+        if ary.first.empty?
+          first = nil
+          ary.shift
+        else
+          first = unescape(ary.shift).to_ber_contextspecific(0)
+        end
+
+        if ary.last.empty?
+          last = nil
+          ary.pop
+        else
+          last = unescape(ary.pop).to_ber_contextspecific(2)
+        end
+
+        seq = ary.map { |e| unescape(e).to_ber_contextspecific(1) }
+        seq.unshift(first) if first
+        seq.push(last) if last
+
+        [
+          field.to_s.to_ber,
+          seq.to_ber
+        ].to_ber_contextspecific(4)
+      end
+
+      def extensible
+        raise(Error, "Bad attribute #{field}") unless field =~ EXTENSIBLE_REGEX
+
+        type = Regexp.last_match(1)
+        dn   = Regexp.last_match(2)
+        rule = Regexp.last_match(4)
+
+        seq = []
+        seq << rule.to_ber_contextspecific(1) unless rule.to_s.empty? # matchingRule
+        seq << type.to_ber_contextspecific(2) unless type.to_s.empty? # type
+        seq << unescape(value).to_ber_contextspecific(3)              # matchingValue
+        seq << '1'.to_ber_contextspecific(4) unless dn.to_s.empty?    # dnAttributes
+
+        seq.to_ber_contextspecific(9)
+      end
+
+      # Common BER encoding
+      #
+      # @return [String]
+      #
+      def to_context(int)
+        [
+          field.to_s.to_ber,
+          unescape(value).to_ber
+        ].to_ber_contextspecific(int)
+      end
+
+      # @note
+      #   Don't attempt to unescape 16 byte binary data assumed to be objectGUIDs.
+      #   The binary form of 5936AE79-664F-44EA-BCCB-5C39399514C6
+      #   triggers a BINARY -> UTF-8 conversion error.
+      #
+      # Converts escaped characters to unescaped characters
+      #
+      # @example
+      #   => "\\28"
+      #
+      # @return [String]
+      #
+      # @api private
+      def unescape(str)
+        if str.to_s.length.eql?(16) && str.to_s.encoding.eql?(Encoding::BINARY)
+          str
+        else
+          str.to_s.gsub(UNESCAPE_REGEX) { [Regexp.last_match(1).hex].pack('U') }
+        end
+      end
+
+    end
+  end
+end