rom-ldap 0.2.2

data/lib/rom/ldap/gateway.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'rom/gateway'
+require 'rom/ldap/directory'
+require 'rom/ldap/dataset'
+
+module ROM
+  module LDAP
+    # @abstract
+    #   Responsible for initialising connection, binding to server.
+    #   Wrapping the connection in the directory and then dataset abstractions,
+    #   and passing them to the relations.
+    #
+    class Gateway < ROM::Gateway
+
+      adapter :ldap
+
+      # @!attribute [r] directory
+      #   @return [String]
+      attr_reader :directory
+
+      # @!attribute [r] logger
+      #   @return [Object] configured gateway logger
+      attr_reader :logger
+
+      # Initialize an LDAP gateway
+      #
+      # Gateways are typically initialized via ROM::Configuration object
+      #
+      # @overload initialize(uri, options)
+      #   Connects to a directory via options
+      #
+      #   @example
+      #     ROM.container(:ldap, uri, {})
+      #
+      #   @param uri [String] 'ldap://127.0.0.1:389' or nil
+      #
+      #   @option options :username [String] BINDDN Directory admin username.
+      #
+      #   @option options :password [String] BINDDN Directory admin password.
+      #
+      #   @option options :base [String] BASE Directory search base.
+      #
+      #   @option options :timeout [Integer] Connection timeout in seconds.
+      #
+      #   @option options :logger [Object] Defaults to $stdout
+      #
+      # @return [LDAP::Gateway]
+      #
+      def initialize(uri = nil, **options)
+        @directory = Directory.new(uri, options)
+        @logger = options.fetch(:logger) { ::Logger.new(STDOUT) }
+
+        options.fetch(:extensions, EMPTY_ARRAY).each do |ext|
+          next unless LDAP.available_extension?(ext)
+
+          LDAP.load_extensions(ext)
+        end
+
+        super()
+      end
+
+      # Used by attribute_inferrer to query attributes.
+      #
+      # @param filter [String]
+      #
+      # @return [Array<Directory::Entry>]
+      #
+      # @api public
+      #
+      def [](filter)
+        directory.query_attributes(filter)
+      end
+      alias_method :call, :[]
+
+      # Directory attributes identifiers and descriptions.
+      #
+      # @see Schema::Inferrer
+      # @see Schema::TypeBuilder
+      #
+      # @return [Array<String>]
+      #
+      # @api public
+      #
+      def attribute_types
+        directory.attribute_types
+      end
+
+      # Check for presence of entries under new filter.
+      #
+      # @param name [String] An ldap compatible filter string.
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      #
+      def dataset?(name)
+        dataset(name).any?
+      end
+
+      # An enumerable object for chainable queries.
+      #
+      # @param name [String] An ldap compatible filter string.
+      #   Used as the param to schema block in relation classes.
+      #
+      # @return [Dataset] Scoped by name filter.
+      #
+      # @api public
+      #
+      def dataset(name)
+        Dataset.new(name: name, directory: directory)
+      end
+
+      # @param logger [Logger]
+      #
+      # @api public
+      #
+      def use_logger(logger)
+        directory.logger = @logger = logger
+      end
+
+      # Underlying directory type
+      #
+      # @return [Symbol]
+      #
+      # @api public
+      #
+      def directory_type
+        directory.type
+      end
+
+      # Disconnect from the server.
+      #
+      # @return [?]
+      #
+      # @api public
+      #
+      def disconnect
+        directory.disconnect
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/ldif.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/ldif/importer'
+require 'rom/ldap/ldif/exporter'
+
+require 'rom/initializer'
+#
+# @see https://docs.oracle.com/cd/E10773_01/doc/oim.1014/e10531/ldif_appendix.htm
+#
+module ROM
+  module LDAP
+    module_function
+
+    #
+    # LDAP Data Interchange Format (LDIF)
+    #
+    # Refines Array and Hash with #to_ldif method.
+    #
+    # @see Directory::Entry
+    # @see Relation::Exporting
+    #
+    module LDIF
+      # @example
+      #
+      #   ROM::LDAP::LDIF("version: 3\n") => [{}]
+      #
+      # @param ldif [String]
+      #
+      # @return [Array<Hash>]
+      #
+      # @api private
+      def self.to_tuples(ldif, &block)
+        Importer.new(ldif).to_tuples(&block)
+      end
+
+      # Extend functionality of Hash class.
+      #
+      refine ::Hash do
+        # Convert hash to LDIF format
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_ldif
+          Exporter.new([self]).to_ldif
+        end
+      end
+
+      # Extend functionality of Array class.
+      #
+      refine ::Array do
+        # Convert array to LDIF format
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_ldif
+          Exporter.new(self).to_ldif
+        end
+      end
+    end
+
+    # Parser for LDIF format
+    # rubocop:disable Naming/MethodName
+    #
+    # alias for LDIF.to_tuples
+    #
+    # @api public
+    def LDIF(ldif, &block)
+      LDIF.to_tuples(ldif, &block)
+    end
+    # rubocop:enable Naming/MethodName
+  end
+end

data/lib/rom/ldap/ldif/exporter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'rom/initializer'
+require 'rom/ldap/functions'
+
+module ROM
+  module LDAP
+    module LDIF
+      # Export Entry objects as LDIF files.
+      #
+      # @param tuple [Array<Hash>]
+      #
+      # @api private
+      class Exporter
+
+        extend Initializer
+
+        param :tuples, type: Types::Strict::Array.of(Types::Strict::Hash)
+
+        # @return [String]
+        #
+        def to_ldif
+          tuples.map { |tuple| create_entry(tuple) }.join(NEW_LINE)
+        end
+
+        private
+
+        # @param tuple [Hash]
+        #
+        # @return [Array<String>]
+        #
+        def create_entry(tuple)
+          ary = []
+          tuple.each do |key, values|
+            values.each { |value| ary << key_value_pair(key, value) }
+          end
+          ary << NEW_LINE
+          ary
+        end
+
+        # @param key [String]
+        # @param value [String]
+        #
+        # @return [String]
+        #
+        def key_value_pair(key, value)
+          if /userpassword/i.match?(key)
+            value = Functions[:to_base64].call(value)
+            "#{key}:: #{value}"
+          elsif value_is_binary?(value)
+            value = Functions[:to_base64].call(value, strict: false)
+            value = value.gsub(/#{NEW_LINE}/m, "#{NEW_LINE} ")
+            "#{key}:: #{value}"
+          else
+            "#{key}: #{value}"
+          end
+        end
+
+        #   jpegphoto:<file:///tmp/myphoto.jpg
+        #   userpassword::qwerty
+        #
+        # @param value [String]
+        #
+        # @return [Boolean]
+        def value_is_binary?(value)
+          return true if value.start_with?(':', '<')
+
+          value.each_byte do |byte|
+            return true if (byte < 32) || (byte > 126)
+          end
+          false
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/ldif/importer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rom/initializer'
+
+module ROM
+  module LDAP
+    module LDIF
+      # LDIF to importable tuples.
+      #
+      # @param ldif [String]
+      #
+      # @api private
+      class Importer
+
+        extend Initializer
+
+        param :ldif, type: Types::Strict::String
+
+        # @example =>
+        #
+        #   [{
+        #                 :dn => "ou=users, dc=rom, dc=ldap",
+        #                "ou" => "users",
+        #       "objectClass" => "organizationalUnit"
+        #   }]
+        #
+        # @return [Array<Hash>]
+        #
+        def to_tuples
+          dataset.map do |entry|
+            next if entry.any? { |l| l.match?(/^version/) }
+
+            abort 'update statements not allowed' if entry.any? { |l| l.match?(/^changetype/) }
+
+            tuple = parse(entry)
+
+            block_given? ? yield(tuple) : tuple
+          end.compact
+        end
+
+        private
+
+        def dataset
+          ldif
+            .split(NEW_LINE)
+            .reject(&method(:comment?))
+            .chunk(&method(:divider?))
+            .reject(&:first)
+            .map(&:pop)
+        end
+
+        def comment?(line)
+          line.match?(/^#/)
+        end
+
+        def divider?(line)
+          line.eql?(EMPTY_STRING)
+        end
+
+        # @param entry [Array<String>]
+        #
+        # @return [Hash]
+        #
+        def parse(entry)
+          entry.map(&method(:key_pair)).inject(&method(:merge))
+        end
+
+        #
+        # @return [Hash]
+        #
+        def key_pair(line)
+          _, key, _, value = line.match(LDIF_LINE_REGEX).to_a
+
+          key = key.to_sym if key.eql?('dn')
+          value = File.binread(Regexp.last_match(1)) if value.match(BIN_FILE_REGEX)
+          value = Functions[:identify_value].call(value)
+
+          { key => value }
+        end
+
+        def merge(original, additional)
+          key, value = additional.to_a.first
+
+          if original.key?(key)
+            original[key] = [*original[key], value]
+            original
+          else
+            original.merge(additional)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/mapper_compiler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rom/mapper_compiler'
+
+module ROM
+  module LDAP
+    class MapperCompiler < ROM::MapperCompiler
+      # def visit_attribute(node)
+      #   name, _, meta_options = node
+
+      #   if meta_options[:wrapped]
+      #     [name, from: meta_options[:alias]]
+      #   else
+      #     [name]
+      #   end
+      # end
+    end
+  end
+end

data/lib/rom/ldap/matchers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    # Type Builder
+    #
+    # @see https://ldap.com/matching-rules/
+    #
+    # Matching Rules - 2.5.13
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    STRING_MATCHERS = %w[
+      2.5.13.0 objectIdentifierMatch
+      2.5.13.1 distinguishedNameMatch
+      2.5.13.2 caseIgnoreMatch
+      2.5.13.3 caseIgnoreOrderingMatch
+      2.5.13.4 caseIgnoreSubstringsMatch
+      2.5.13.5 caseExactMatch
+      2.5.13.6 caseExactOrderingMatch
+      2.5.13.7 caseExactSubstringsMatch
+      2.5.13.8 numericStringMatch
+      2.5.13.9 numericStringOrderingMatch
+      2.5.13.10 numericStringSubstringsMatch
+      2.5.13.11 caseIgnoreListMatch
+      2.5.13.12 caseIgnoreListSubstringsMatch
+      2.5.13.17 octetStringMatch
+      2.5.13.18 octetStringOrderingMatch
+      2.5.13.20 telephoneNumberMatch
+      2.5.13.21 telephoneNumberSubstringsMatch
+      2.5.13.24 protocolInformationMatch
+      2.5.13.30 objectIdentifierFirstComponentMatch
+
+      1.3.6.1.1.16.2 uuidMatch
+      1.3.6.1.1.16.3 uuidOrderingMatch
+
+      1.3.6.1.4.1.1466.109.114.1 caseExactIA5Match
+      1.3.6.1.4.1.1466.109.114.2 caseIgnoreIA5Match
+      1.3.6.1.4.1.1466.109.114.3 caseIgnoreIA5SubstringsMatch
+    ].freeze
+
+    # @return [Array<String>]
+    #
+    # @api private
+    BOOLEAN_MATCHERS = %w[
+      2.5.13.13 booleanMatch
+    ].freeze
+
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    INTEGER_MATCHERS = %w[
+      2.5.13.14 integerMatch
+      2.5.13.15 integerOrderingMatch
+    ].freeze
+
+    # @return [Array<String>]
+    #
+    # @api private
+    TIME_MATCHERS = %w[
+      csnMatch
+      2.5.13.25 uTCTimeMatch
+      2.5.13.27 generalizedTimeMatch
+      2.5.13.28 generalizedTimeOrderingMatch
+    ].freeze
+  end
+end