rom-ldap 0.2.2

data/lib/rom/ldap/dataset/conversion.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/parsers/abstract_syntax'
+require 'rom/ldap/parsers/filter_syntax'
+
+module ROM
+  module LDAP
+    class Dataset
+
+      # Parsing Formats
+      #
+      # @api public
+      module Conversion
+        # Extends the class with filter abstraction behavior.
+        #
+        # @api private
+        def self.included(klass)
+          klass.class_eval do
+            extend Dry::Core::ClassAttributes
+
+            defines :filter_class
+            filter_class Parsers::FilterSyntax
+
+            defines :ast_class
+            ast_class Parsers::AbstractSyntax
+          end
+        end
+
+        # Convert the full query to an LDAP filter string
+        #
+        # @return [String]
+        #
+        # @api private
+        def to_filter
+          self.class.ast_class.new(to_ast, directory.attribute_types).call.to_filter
+        end
+
+        # Combine original relation dataset name (LDAP filter string)
+        #   with search criteria (AST).
+        #
+        # @return [Array]
+        #
+        # @api private
+        def to_ast
+          criteria.empty? ? source_ast : [:con_and, [source_ast, criteria]]
+        end
+
+        private
+
+        # Convert the relation's source filter string to a query AST.
+        #
+        # @return [Array]
+        #
+        # @api private
+        def source_ast
+          self.class.filter_class.new(name, directory.attribute_types).call
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    class Dataset
+
+      # AST Query Interface
+      #
+      # @api private
+      module DSL
+        # Invert the whole query
+        #
+        # @return [Dataset]
+        def inverse
+          with(criteria: [:con_not, criteria])
+        end
+
+        # Equality filter aliased as 'where'.
+        #
+        # @example
+        #   relation.where(uid: 'Pietro')
+        #   relation.where(uid: %w[Pietro Wanda])
+        #   relation.where(uid: 'Pietro', sn: 'Maximoff')
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def equal(args)
+          chain(*array_dsl(args))
+        end
+
+        # Antonym of 'equal'
+        #
+        # @example
+        #   relation.unequal(uid: 'Pietro')
+        #   relation.unequal(uid: %w[Pietro Wanda])
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def unequal(args)
+          chain(:con_not, array_dsl(args))
+        end
+
+        # Presence filter aliased as 'has'.
+        #
+        # @example
+        #   relation.present(:uid)
+        #   relation.has(:mail)
+        #
+        # @param attribute [Symbol]
+        #
+        # @return [Dataset]
+        def present(attribute)
+          chain(:op_eql, attribute, :wildcard)
+        end
+        alias_method :has, :present
+
+        # Absence filter aliased as 'hasnt'. Inverse of 'present'.
+        #
+        # @example
+        #   relation.missing(:uid)
+        #   relation.hasnt(:mail)
+        #
+        # @param attribute [Symbol]
+        #
+        # @return [Dataset]
+        def missing(attribute)
+          chain(:con_not, [:op_eql, attribute, :wildcard])
+        end
+        alias_method :hasnt, :missing
+
+        # Greater than filter
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def gt(args)
+          chain(:con_not, [:op_lte, *args.to_a[0]])
+        end
+        alias_method :above, :gt
+
+        # Less than filter
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def lt(args)
+          chain(:con_not, [:op_gte, *args.to_a[0]])
+        end
+        alias_method :below, :lt
+
+        # Greater than or equal filter
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def gte(args)
+          chain(:op_gte, *args.to_a[0])
+        end
+
+        # Less than or equal filter
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def lte(args)
+          chain(:op_lte, *args.to_a[0])
+        end
+
+        # Starts with filter
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def begins(args)
+          chain(*match_dsl(args, right: WILDCARD))
+        end
+
+        # Ends with filter
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def ends(args)
+          chain(*match_dsl(args, left: WILDCARD))
+        end
+
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def contains(args)
+          chain(*match_dsl(args, left: WILDCARD, right: WILDCARD))
+        end
+        alias_method :matches, :contains
+
+        # negate #contains
+        #
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def excludes(args)
+          chain(:con_not, match_dsl(args, left: WILDCARD, right: WILDCARD))
+        end
+
+        # @param args [Range]
+        #
+        # @return [Dataset]
+        def within(args)
+          chain(:con_and, cover_dsl(args))
+        end
+        alias_method :between, :within
+
+        # negate #outside
+        #
+        # @param args [Range]
+        #
+        # @return [Dataset]
+        def outside(args)
+          chain(:con_not, [:con_and, cover_dsl(args)])
+        end
+
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def binary_equal(args)
+          chain(:op_bineq, *args.to_a[0])
+        end
+
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def approx(args)
+          chain(:op_prx, *args.to_a[0])
+        end
+
+        # @param args [Hash]
+        #
+        # @return [Dataset]
+        def bitwise(args)
+          chain(:op_ext, *args.to_a[0])
+        end
+
+        private
+
+        # Update the criteria.
+        #   If criteria already exist join with AND.
+        #
+        # @example
+        #   chain(:op_eql, :uid,  "*foo*")
+        #
+        # @param exprs [Mixed] AST built by QueryDSL
+        #
+        # @return [Dataset]
+        def chain(*exprs)
+          if criteria.empty?
+            with(criteria: exprs)
+          else
+            with(criteria: [:con_and, [criteria, exprs]])
+          end
+        end
+
+        # Handle multiple criteria with an OR join.
+        #   @see #chain for AND join.
+        #
+        # @param args [Hash]
+        #
+        # @return [Array] AST
+        #
+        # @example
+        #   array_dsl(sn: 'Maximoff', gn: %w[Wanda Pietror])
+        #   =>
+        #       [ :con_or,
+        #         [
+        #           [ :op_eql, :sn, "Maximoff" ],
+        #           [ :con_or,
+        #             [
+        #               [ :op_eql, :gn, "Wanda" ],
+        #               [ :op_eql, :gn, "Pietror" ]
+        #             ]
+        #           ]
+        #         ]
+        #       ]
+        #
+        def array_dsl(args)
+          expressions = args.map do |left, right|
+            values = Array(right).map { |v| [:op_eql, left, escape(v)] }
+            join_dsl(:con_or, values)
+          end
+          join_dsl(:con_or, expressions)
+
+          # join_dsl(:con_or, [ match_dsl(args.map(&:to_a)) ])
+          # join_dsl(:con_or, args.map { |arg| match_dsl([arg]) })
+        end
+
+        # Wrap criteria with a join operator.
+        #
+        # @param operator [Symbol] :con_or, :con_and
+        #
+        # @param ary [Array] [[op, left, right],[op, left, right]]
+        def join_dsl(operator, ary)
+          ary.size >= 2 ? [operator, ary] : ary.first
+        end
+
+        # Wrap criteria value with extra characters, used for wildcard
+        #
+        # @param args [Array]
+        #
+        # @option :left  [String] Prepended to value.
+        # @option :right [String] Appended to value.
+        #
+        # @return [Array]
+        #
+        # @example
+        #   match_dsl(bar: 'foo', left: '*', right: '*')
+        #       => [:op_eql, :bar, '*foo*']
+        #
+        def match_dsl(args, left: EMPTY_STRING, right: EMPTY_STRING)
+          expressions = args.map do |att, val|
+            values = Array(val).map do |v|
+              value = left.to_s + escape(v) + right.to_s
+              [:op_eql, att, value]
+            end
+
+            join_dsl(:con_or, values)
+          end
+          join_dsl(:con_or, expressions)
+        end
+
+        #
+        # @param args [Range,Array]
+        #
+        # @return [Array]
+        def cover_dsl(args)
+          attribute, range = args.to_a[0]
+          lower, *_, upper = range.to_a
+
+          lower = [:op_gte, attribute, lower]
+          upper = [:op_lte, attribute, upper]
+
+          [lower, upper]
+        end
+
+        # If any of the following special characters appear in the
+        # search filter as literals, they must be escaped with a backslash.
+        #
+        # "(", ")", "\", ,"/" "*", "null"
+        #
+        # @param value [String, Integer]
+        #
+        # @return [String]
+        def escape(value)
+          value.to_s.gsub(ESCAPE_REGEX) { |char| '\\' + ESCAPES[char] }
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/dataset/persistence.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    class Dataset
+
+      module Persistence
+        # Interface to Directory#add
+        #
+        # @param tuple [Hash]
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def add(tuple)
+          directory.add(tuple)
+        end
+
+        # Interface to Directory#modify
+        #
+        # @param tuple [Changeset, Hash] Modification params
+        #
+        # @return [Array<Directory::Entry, Boolean>]
+        #
+        # @api public
+        def modify(tuple)
+          map { |e| directory.modify(e.dn, tuple) }
+        end
+
+        # Interface to Directory#delete
+        #
+        # @see Directory::Operations#delete
+        #
+        # @return [Array<Directory::Entry, Boolean>]
+        #
+        # @api public
+        def delete
+          map { |e| directory.delete(e.dn) }
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/directory.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/client'
+
+require 'rom/ldap/directory/env'
+require 'rom/ldap/directory/entry'
+require 'rom/ldap/directory/root'
+require 'rom/ldap/directory/capabilities'
+require 'rom/ldap/directory/operations'
+require 'rom/ldap/directory/transactions'
+require 'rom/ldap/directory/tokenization'
+
+module ROM
+  module LDAP
+    # @abstract
+    #   Builds LDAP directory abstraction over TCP connection instance.
+    #   Includes vendor specific modules once initialised.
+    #
+    class Directory
+
+      attr_accessor :logger
+      attr_reader :env
+
+      # Load vendor specific methods into the instance as singletons
+      #
+      # @see Gateway#directory
+      #
+      # @return [ROM::LDAP::Directory]
+      #
+      def initialize(uri, options)
+        @env    = ENV.new(uri, options)
+        @logger = options.fetch(:logger, Logger.new($stdout))
+
+        require "rom/ldap/directory/vendors/#{type}"
+        extend LDAP.const_get(Inflector.camelize(type))
+      end
+
+      include Root
+      include Capabilities
+      include Tokenization
+      include Operations
+      include Transactions
+
+      # Initial search base.
+      #
+      # @return [String] Defaults to empty string.
+      #
+      # @api public
+      def base
+        env.base
+      end
+
+      # Encapsulates encoding and binding using socket.
+      #
+      # @return [Client]
+      #
+      def client
+        @client ||= Client.new(env.to_h)
+      end
+
+      # Expected method inside gateway.
+      #
+      # @return [TrueClass]
+      #
+      def disconnect
+        client.close
+        client.closed?
+      end
+
+      # Parsed attributes.
+      # Output influenced by LDAP.formatter. Ordered alphabetically.
+      #
+      # @return [Array<Hash>]
+      #
+      def attribute_types
+        @attribute_types ||= schema_attribute_types.map(&method(:to_attribute)).flatten.freeze
+      end
+
+      # Look up canonical name for a formatted attribute.
+      #
+      # @see Dataset#order_by and Dataset#select
+      #
+      # @param attrs [Array<Symbol,String>] formatted attribute names.
+      #
+      # @return [Array<String>] camelCased canonical LDAP attributes.
+      #
+      def canonical_attributes(attrs)
+        attrs.map do |formatted|
+          attribute_by(:name, formatted).fetch(:canonical, formatted.to_s)
+        end
+      end
+
+      # Query parsed attribute definition hashes by key.
+      #
+      # @example
+      #   directory.attribute_by(:name, :jpeg_photo) => { name: :jpeg_photo, ...}
+      #
+      # @param key [Symbol]
+      # @param value [Mixed]
+      #
+      # @return [Hash]
+      #
+      def attribute_by(key, value)
+        attribute_types.find { |a| a[key].eql?(value) } || EMPTY_HASH
+      end
+
+      # Hash of attribute names converted => original
+      #
+      # @example { formatted_name: 'canonicalName' }
+      #
+      # @return [Hash]
+      #
+      def key_map
+        attribute_types.map { |a| a.values_at(:name, :canonical) }.sort.to_h
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        "#<#{self.class} uri='#{env.connection}' vendor='#{vendor_name}' version='#{vendor_version}' />"
+      end
+
+    end
+  end
+end