rom-ldap 0.2.2

data/lib/rom-ldap.rb

@@ -0,0 +1 @@
+require 'rom/ldap'

data/lib/rom/ldap.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rom/core'
+require 'rom/configuration_dsl'
+
+require 'rom/ldap/version'
+require 'rom/ldap/constants'
+require 'rom/ldap/formatter'
+require 'rom/ldap/errors'
+require 'rom/ldap/plugins'
+require 'rom/ldap/relation'
+require 'rom/ldap/mapper_compiler'
+require 'rom/ldap/associations'
+require 'rom/ldap/gateway'
+require 'rom/ldap/commands'
+require 'rom/ldap/extensions'
+
+if defined?(Rails)
+  ROM::LDAP.load_extensions(:active_support_notifications, :rails_log_subscriber)
+end
+
+ROM.register_adapter :ldap, ROM::LDAP

data/lib/rom/ldap/alias.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    #
+    # Alias Dereferencing [RFC4512]
+    #
+    # An indicator as to whether or not alias entries are to be dereferenced.
+    #
+    # Dereferencing aliases can cause poor search performance for some LDAP directories.
+    # Control the extent to which alias dereferencing occurs when searching the directory.
+
+    # Do not dereference aliases in searching or in locating the base object of the search.
+    DEREF_NEVER  = 0 # "never"
+
+    # While searching subordinates of the base object, dereference any alias within the search scope.
+    DEREF_SEARCH = 1 # "searching"
+
+    # Dereference aliases in locating the base object of the search, but not
+    # when searching subordinates of the base object.
+    DEREF_FIND   = 2 # "finding"
+
+    # Always dereference aliases both in searching and in locating the base object of the search.
+    # is the default behavior.
+    DEREF_ALWAYS = 3 # "always"
+
+    # Array of all dereferencing modes
+    DEREF_ALL = [DEREF_NEVER, DEREF_SEARCH, DEREF_FIND, DEREF_ALWAYS].freeze
+  end
+end

data/lib/rom/ldap/associations.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/associations/many_to_many'
+require 'rom/ldap/associations/many_to_one'
+require 'rom/ldap/associations/one_to_many'
+require 'rom/ldap/associations/one_to_one'

data/lib/rom/ldap/associations/core.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    module Associations
+      # Core LDAP association API
+      #
+      # @api private
+      module Core
+        # Used when relation association override is not true
+        #
+        # @see https://github.com/rom-rb/rom/blob/master/core/lib/rom/relation.rb#L319
+        #
+        # @api private
+        def preload(target, loaded)
+          source_key, target_key = join_keys.flatten(1)
+          target_pks = loaded.pluck(source_key.key).flatten.uniq
+          target.where(target_key.key => target_pks)
+        end
+      end
+    end
+  end
+end

data/lib/rom/ldap/associations/many_to_many.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rom/associations/many_to_many'
+
+module ROM
+  module LDAP
+    module Associations
+      class ManyToMany < ROM::Associations::ManyToMany
+
+        # @api public
+        def call(*)
+          # binding.pry
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/associations/many_to_one.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rom/associations/many_to_one'
+
+module ROM
+  module LDAP
+    module Associations
+      class ManyToOne < ROM::Associations::ManyToOne
+
+        # @api public
+        def call(*)
+          # binding.pry
+        end
+
+        def join(source = self.source, target = self.target)
+          # binding.pry
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/associations/one_to_many.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rom/associations/one_to_many'
+
+require 'rom/ldap/associations/core'
+require 'rom/ldap/associations/self_ref'
+
+module ROM
+  module LDAP
+    module Associations
+      class OneToMany < ROM::Associations::OneToMany
+
+        include Associations::Core
+        include Associations::SelfRef
+
+        # @api public
+        def call(target: self.target)
+          schema = target.schema
+          target_fks = target.list(foreign_key).uniq
+          relation = source.where(source.primary_key => target_fks)
+
+          if view
+            apply_view(schema, relation)
+          else
+            schema.call(relation)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/associations/one_to_one.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/associations/one_to_many'
+
+module ROM
+  module LDAP
+    module Associations
+      class OneToOne < OneToMany
+
+        # @api public
+        def call(*)
+          # binding.pry
+          super
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/associations/self_ref.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    module Associations
+      module SelfRef
+        def self.included(klass)
+          super
+          klass.memoize :join_keys, :source_attr, :target_attr
+        end
+
+        # @return [Hash]
+        #
+        # @api public
+        def join_keys
+          { source_attr => target_attr }
+        end
+
+        # @return [ROM::LDAP::Attribute]
+        #
+        # @api public
+        def source_attr
+          source[source_key]
+        end
+
+        # @return [ROM::LDAP::Attribute]
+        #
+        # @api public
+        def target_attr
+          target[target_key]
+        end
+      end
+    end
+  end
+end

data/lib/rom/ldap/attribute.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+require 'dry/core/cache'
+require 'rom/attribute'
+
+module ROM
+  module LDAP
+    # Extended schema attributes tailored for LDAP directories
+    #
+    # @api public
+    class Attribute < ROM::Attribute
+
+      extend Dry::Core::Cache
+
+      # @param args [Mixed]
+      #
+      # @return [ROM::LDAP::Attribute]
+      #
+      # @api public
+      def self.[](*args)
+        fetch_or_store(args) { new(*args) }
+      end
+
+      # Attribute definition identifies this is not a directory internal attribute
+      # and values can be altered.
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def editable?
+        meta[:editable].equal?(true)
+      end
+
+      # Attribute definition identifies this attribute can not have multiple values.
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def single?
+        meta[:single].equal?(true)
+      end
+
+      # OID permits multiple values?
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def multiple?
+        meta[:single].equal?(false)
+      end
+
+      # Return a new attribute marked as joined
+      #
+      # Whenever you join two schemas, the right schema's attribute
+      # will be marked as joined using this method
+      #
+      # @return [LDAP::Attribute] Original attribute marked as joined
+      #
+      # @api public
+      def joined
+        meta(joined: true)
+      end
+
+      # Return if an attribute was used in a join
+      #
+      # @example
+      #   schema = users.schema.join(tasks.schema)
+      #
+      #   schema[:id, :tasks].joined?
+      #   # => true
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def joined?
+        meta[:joined].equal?(true)
+      end
+
+      # Return a new attribute marked as a FK
+      #
+      # @return [LDAP::Attribute]
+      #
+      # @api public
+      def foreign_key
+        meta(foreign_key: true)
+      end
+
+      # Attribute Numeric Object Identifier
+      #
+      # @return [String]
+      #
+      # @api public
+      def oid
+        meta[:oid]
+      end
+
+      # Raw LDAP Attribute Definition.
+      #
+      # @return [String]
+      #
+      # @api public
+      def definition
+        meta[:definition]
+      end
+
+      # Attribute's syntax Numeric Object Identifier
+      #
+      # @return [String]
+      #
+      # @api public
+      def syntax
+        meta[:syntax]
+      end
+
+      # OID description
+      #
+      # @return [String]
+      #
+      # @api public
+      def description
+        meta[:description]
+      end
+
+      # Convert to string for ldap query using original name
+      # The canonical attribute name defined in RFC4512.
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_s
+        meta[:canonical] || name.to_s
+      end
+      alias_method :original_name, :to_s
+
+      # @return [Boolean]
+      #
+      # @api public
+      def indexed?
+        meta[:index].equal?(true)
+      end
+
+      # Returns a new attribute marked as indexed
+      #
+      # @return [LDAP::Attribute]
+      #
+      # @api public
+      def indexed
+        meta(index: true)
+      end
+
+      # Return a new attribute in its canonical form
+      #
+      # @see Dataset#export
+      #
+      # @return [LDAP::Attribute]
+      #
+      # @api public
+      def canonical
+        if aliased?
+          meta(alias: nil)
+        else
+          self
+        end
+      end
+
+      # @example
+      #   users.where { given_name.exists }
+      #   users.where { ~given_name }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def exists
+        [:op_eql, name, :wildcard]
+      end
+      alias_method :~@, :exists
+
+      # @example
+      #   users.where { !given_name }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def !@
+        [:con_not, exists]
+      end
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { id.is(1) }
+      #   users.where { id == 1 }
+      #
+      #   users.where(users[:id].is(1))
+      #
+      # @return [Array]
+      #
+      # @api public
+      def is(value)
+        [:op_eql, name, value]
+      end
+      alias_method :==, :is
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { id.not(1) }
+      #   users.where { id != 1 }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def not(value)
+        [:con_not, is(value)]
+      end
+      alias_method :!=, :not
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { uid_number.gt(101) }
+      #   users.where { uid_number > 101 }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def gt(value)
+        [:con_not, lte(value)]
+      end
+      alias_method :>, :gt
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { uid_number.lt(101) }
+      #   users.where { uid_number < 101 }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def lt(value)
+        [:con_not, gte(value)]
+      end
+      alias_method :<, :lt
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { uid_number.gte(101) }
+      #   users.where { uid_number >= 101 }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def gte(value)
+        [:op_gte, name, value]
+      end
+      alias_method :>=, :gte
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { uid_number.lte(101) }
+      #   users.where { uid_number <= 101 }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def lte(value)
+        [:op_lte, name, value]
+      end
+      alias_method :<=, :lte
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { given_name.like('peter') }
+      #   users.where { given_name =~ 'peter' }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def like(value)
+        [:op_prx, name, value]
+      end
+      alias_method :=~, :like
+
+      # @param value [Mixed]
+      #
+      # @example
+      #   users.where { given_name.not_like('peter') }
+      #   users.where { given_name !~ 'peter' }
+      #
+      # @return [Array]
+      #
+      # @api public
+      def not_like(value)
+        [:con_not, like(value)]
+      end
+      alias_method :!~, :not_like
+
+      # @param value [Mixed]
+      #
+      # @see https://ldapwiki.com/wiki/ExtensibleMatch
+      #
+      # @return [Array]
+      #
+      # @api public
+      def extensible(value)
+        [:op_ext, name, value]
+      end
+
+      # @param value [Mixed]
+      #
+      # @return [Array]
+      #
+      # @api public
+      def bitwise(value)
+        [:op_eql, name, value]
+      end
+      alias_method :===, :bitwise
+
+      memoize :oid, :syntax, :joined, :canonical, :to_s
+
+    end
+  end
+end