rom-ldap 0.2.2

data/lib/rom/ldap/relation/writing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    class Relation < ROM::Relation
+
+      module Writing
+        # @example
+        #   relation.insert(
+        #     dn: 'uid=batman,ou=comic,dc=rom,dc=ldap',
+        #     cn: 'The Dark Knight',
+        #     uid: 'batman',
+        #     given_name: 'Bruce',
+        #     sn: 'Wayne',
+        #     apple_imhandle: 'bruce-wayne',
+        #     object_class: %w[extensibleObject inetOrgPerson]
+        #   )
+        #     #=>
+        #   {
+        #     dn: 'uid=batman,ou=comic,dc=rom,dc=ldap',
+        #     cn: 'The Dark Knight',
+        #     uid: 'batman',
+        #     given_name: 'Bruce',
+        #     sn: 'Wayne',
+        #     apple_imhandle: 'bruce-wayne',
+        #     object_class: %w[top extensibleObject inetOrgPerson]
+        #   }
+        #
+        # @param tuple [Hash]
+        #
+        # @return [Array<Directory::Entry, FalseClass>]
+        #
+        # @api public
+        def insert(tuple)
+          dataset.add(tuple)
+        end
+
+        # @example
+        #   relation.update(mail: 'fear_the_bat@gotham.com')
+        #   #=>  {}
+        #
+        # @param tuple [Hash]
+        #
+        # @return [Array<Directory::Entry, FalseClass>]
+        #
+        # @api public
+        def update(tuple)
+          dataset.modify(tuple)
+        end
+
+        # @example
+        #   relation.delete #=> { uid: 'batman'}
+        #
+        # @return [Array<Directory::Entry, FalseClass>]
+        #
+        # @api public
+        def delete
+          dataset.delete
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/responses.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+
+module ROM
+  module LDAP
+    #
+    # Loaded by PDU
+    #
+    # @see https://tools.ietf.org/html/rfc4511#section-4.1.9
+    #
+    RESPONSES_PATH = Pathname(__dir__).join('../../../config/responses.yml').realpath.freeze
+
+    RESPONSES = ::YAML.load_file(RESPONSES_PATH).freeze
+  end
+end

data/lib/rom/ldap/restriction_dsl.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/dsl'
+require 'rom/ldap/parsers/filter_syntax'
+
+module ROM
+  module LDAP
+    # @api private
+    class RestrictionDSL < DSL
+
+      # @api private
+      def call(&block)
+        instance_exec(select_relations(block.parameters), &block)
+      end
+
+      # Parse a raw query to AST.
+      #
+      # @param [String] value
+      #
+      # @return [AST]
+      #
+      # @example
+      #   animals.where { `(cn=dodo)` }.count
+      #
+      # @api public
+      def `(value)
+        Parsers::FilterSyntax.new(value, EMPTY_ARRAY).call
+      end
+
+      private
+
+      # @return [Attribute, Type]
+      #
+      # @api private
+      def method_missing(meth, *args, &block)
+        if schema.key?(meth)
+          schema[meth]
+        else
+          type(meth)
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/schema.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'rom/schema'
+require 'rom/ldap/schema/dsl'
+require 'rom/ldap/restriction_dsl'
+require 'rom/ldap/projection_dsl'
+require 'rom/ldap/schema/inferrer'
+
+module ROM
+  module LDAP
+    class Schema < ROM::Schema
+
+      # Open restriction DSL for defining query conditions using schema attributes
+      #
+      # @see Relation#where
+      #
+      # @return [Mixed] Result of the block call
+      #
+      # @api public
+      def restriction(&block)
+        RestrictionDSL.new(self).call(&block)
+      end
+
+      # Create a new relation based on the schema definition
+      #
+      # @param relation [Relation] The source relation
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def call(relation)
+        dataset = relation.dataset.with(attrs: map(&:name), aliases: map(&:alias))
+        relation.new(dataset, schema: self)
+      end
+
+      # Rename schema attributes
+      #
+      # @see Relation#rename
+      #
+      # @return [Schema] A new schema with renamed attributes
+      #
+      # @api public
+      def rename(mapping)
+        super map(&:name).map { |k| { k => k } }.reduce(&:merge).merge(mapping)
+      end
+
+      # Project a schema
+      #
+      # @see ROM::Schema#project
+      # @see Relation#select
+      #
+      # @return [Schema] A new schema with projected attributes
+      #
+      # @api public
+      def project(*names, &block)
+        if block
+          super(*(names + ProjectionDSL.new(self).call(&block)))
+        else
+          super
+        end
+      end
+
+      # Project schema so that it only contains primary key
+      #
+      # @return [Schema]
+      #
+      # @api private
+      def project_pk
+        project(*primary_key_names)
+      end
+
+      # Project schema so that it only contains renamed foreign key
+      #
+      # @return [Schema]
+      #
+      # @api private
+      def project_fk(mapping)
+        new(rename(mapping).map(&:foreign_key))
+      end
+
+      # Join with another schema
+      #
+      # @param [Schema] other The other schema to join with
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def join(other)
+        merge(other.joined)
+      end
+
+      # Return a new schema with all attributes marked as joined
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def joined
+        new(map(&:joined))
+      end
+
+      # Return an empty schema
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def empty
+        new(EMPTY_ARRAY)
+      end
+
+      # @api private
+      def finalize_associations!(relations:)
+        super do
+          associations.map do |definition|
+            LDAP::Associations.const_get(definition.type).new(definition, relations)
+          end
+        end
+      end
+
+      memoize :project_pk, :canonical, :joined
+
+    end
+  end
+end

data/lib/rom/ldap/schema/attributes_inferrer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rom/initializer'
+
+module ROM
+  module LDAP
+    class Schema < ROM::Schema
+
+      # @api private
+      class AttributesInferrer
+
+        extend Initializer
+
+        option :type_builder
+        option :attr_class, optional: true
+
+        # @api private
+        def call(schema, gateway)
+          dataset = schema.name.dataset
+          columns = dataset_attributes(gateway, dataset)
+
+          inferred = columns.map do |name|
+            type = type_builder.call(name, schema.name)
+            attr_class.new(type, name: name.to_sym)
+          end
+
+          missing = columns - inferred.map { |attr| attr.meta[:name] }
+
+          [inferred, missing]
+        end
+
+        # @api private
+        def with(new_options)
+          self.class.new(options.merge(new_options))
+        end
+
+        private
+
+        # All possible formatted Entry attribute names.
+        #
+        # @see Directory#query_attributes
+        #
+        # @param dataset [String] LDAP filter string / dataset name
+        # @param gateway [ROM::LDAP::Gateway]
+        #
+        # @return [Array<Symbol, String>]
+        #
+        # @example => [:cn, :dn, :given_name, :mail, :object_class, :sn]
+        #
+        # @api private
+        def dataset_attributes(gateway, dataset)
+          gateway[dataset].flat_map(&:keys).uniq.sort
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/schema/dsl.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    class Schema < ROM::Schema
+
+      # @api public
+      class DSL < ROM::Schema::DSL
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/schema/inferrer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/schema/type_builder'
+require 'rom/ldap/schema/attributes_inferrer'
+require 'rom/ldap/attribute'
+
+module ROM
+  module LDAP
+    class Schema < ROM::Schema
+
+      # @api private
+      class Inferrer < ROM::Schema::Inferrer
+
+        attributes_inferrer ->(schema, gateway, options) do
+          builder  = TypeBuilder.new(gateway.attribute_types)
+          inferrer = AttributesInferrer.new(type_builder: builder, **options)
+          inferrer.call(schema, gateway)
+        end
+
+        attr_class LDAP::Attribute
+
+        option :silent, default: -> { false }
+
+        option :raise_on_error, default: -> { true }
+
+        FALLBACK_SCHEMA = {
+          attributes: EMPTY_ARRAY,
+          indexes:    EMPTY_SET
+        }.freeze
+
+        # @api private
+        def call(schema, gateway)
+          inferred = super
+
+          { **inferred }
+        rescue *CONNECTION_FAILURES => e
+          raise ConnectionError, e
+        ensure
+          FALLBACK_SCHEMA
+        end
+
+        def suppress_errors
+          with(raise_on_error: false, silent: true)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/schema/type_builder.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/types'
+require 'rom/initializer'
+
+module ROM
+  module LDAP
+    class Schema
+
+      #
+      # ATTRIBUTE TYPE
+      #
+      # An attribute type is a schema element that correlates an OID and a set of
+      # names with an attribute syntax and a set of matching rules.
+      #
+      # The components of an attribute type definition include:
+      #
+      #     - An OID used to uniquely identify the attribute type.
+      #     - A set of zero or more names that can be used to more easily reference the attribute type.
+      #     - An optional equality matching rule that specifies how equality matching
+      #       should be performed on values of that attribute.
+      #       If no equality matching rule is specified, then the default equality rule
+      #       for the associated attribute syntax will be used.
+      #       If the associated syntax doesn't have a default equality matching rule,
+      #       then equality operations will not be allowed for that attribute.
+      #     - An optional ordering matching rule that specifies how ordering operations
+      #       should be performed on values of that attribute.
+      #       If no ordering matching rule is specified, then the default ordering rule
+      #       for the associated attribute syntax will be used.
+      #       If the associated syntax doesn't have a default ordering matching rule,
+      #       then ordering operations will not be allowed for that attribute.
+      #     - An optional substring matching rule that specifies how substring matching
+      #       should be performed on values of that attribute.
+      #       If no substring matching rule is specified, then the default substring rule
+      #       for the associated attribute syntax will be used.
+      #       If the associated syntax doesn't have a default substring matching rule,
+      #       then substring operations will not be allowed for that attribute.
+      #     - An optional syntax OID that specifies the syntax for values of the attribute.
+      #       If no syntax is specified, then it will default to the directory string syntax.
+      #     - A flag that indicates whether the attribute is allowed to have multiple values.
+      #     - An optional attribute usage string indicating the context in which the attribute is to be used.
+      #     - An optional flag that indicates whether the attribute can be modified by external clients.
+      #
+      # @see Directory.attributes
+      #
+      # @see <https://docs.oracle.com/cd/E19450-01/820-6173/def-attribute-type.html>
+      #
+      # @param attributes [Array<Hash>]
+      #
+      # @api private
+      class TypeBuilder
+
+        extend Initializer
+
+        param :attributes
+
+        # @param attribute_name [String, Symbol]
+        #
+        # @param schema [Schema] Relation schema object.
+        #
+        # @api public
+        def call(attribute_name, schema)
+          attribute = find_attribute(attribute_name)
+          primitive = map_type(attribute)
+          ruby_type = Types.const_get(primitive)
+          read_type = !attribute[:single] ? Types.const_get(Inflector.pluralize(primitive)) : ruby_type
+
+          ruby_type.meta(
+            **attribute,
+            source:   schema,
+            name:     attribute_name,
+            read:     read_type.meta(oid: attribute[:oid])
+          )
+        end
+
+        private
+
+        # Attribute whose formatted name matches the attribute name.
+        #
+        # @param name [Symbol, String]
+        #
+        # @return [Hash]
+        #
+        # @api private
+        def find_attribute(name)
+          attributes.find { |a| a[:name].eql?(name) } || EMPTY_HASH
+        end
+
+        # Map attribute to Type using known syntax or by inferring from the matchers.
+        #
+        # @option :syntax  [String] attribute syntax
+        # @option :matcher [String] attribute matcher
+        #
+        # @return [String]
+        #
+        # @api private
+        def map_type(syntax: nil, matcher: nil, **)
+          by_syntax(syntax) or by_matcher(matcher)
+        end
+
+        # @param oid [String] LDAP Object Identifier
+        #
+        # @example
+        #   by_syntax('1.3.6.1.4.1.1466.115.121.1.24') => Time
+        #
+        # @return [String]
+        #
+        # @api private
+        def by_syntax(oid)
+          OID_TYPE_MAP[oid]
+        end
+
+        # @param matcher [String]
+        #
+        # @return [String]
+        #
+        # @api private
+        def by_matcher(matcher)
+          case matcher
+          when *STRING_MATCHERS  then 'String'
+          when *BOOLEAN_MATCHERS then 'Bool'
+          when *INTEGER_MATCHERS then 'Integer'
+          when *TIME_MATCHERS    then 'Time'
+          else
+            'String'
+          end
+        end
+
+      end
+
+    end
+  end
+end