rom-ldap 0.2.2

data/lib/rom/ldap/extensions.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry/core/extensions'
+
+module ROM
+  module LDAP
+    extend Dry::Core::Extensions
+
+    # Make entry attributes suitable method names.
+    #
+    register_extension(:compatibility) do
+      require 'rom/ldap/extensions/compatibility'
+    end
+
+    #=======================================
+    # Exporters
+    #=======================================
+
+    # Add #to_dsml method to relation instance.
+    #
+    register_extension(:dsml_export) do
+      require 'rom/ldap/extensions/dsml'
+    end
+
+    # Add #to_msgpack method to relation instance.
+    #
+    register_extension(:msgpack_export) do
+      require 'rom/ldap/extensions/msgpack'
+    end
+
+    # Patch #to_json method in relation instance.
+    #
+    register_extension(:oj_export) do
+      require 'rom/ldap/extensions/optimised_json'
+    end
+
+
+    #=======================================
+    # Autoloaded for Rails
+    #=======================================
+
+    register_extension(:active_support_notifications) do
+      require 'rom/ldap/extensions/active_support_notifications'
+    end
+
+    register_extension(:rails_log_subscriber) do
+      require 'rom/ldap/extensions/rails_log_subscriber'
+    end
+  end
+end

data/lib/rom/ldap/extensions/active_support_notifications.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+
+module ROM
+  module LDAP
+    module ActiveSupportInstrumentation
+      def call(filter)
+        ActiveSupport::Notifications.instrument(
+          'ldap.rom',
+          ldap: 'foobar',
+          name: instrumentation_name,
+          binds: filter
+        ) { super }
+      end
+
+      private
+
+      def instrumentation_name
+        "ROM[#{directory.type}]"
+      end
+    end
+
+    Dataset.prepend ActiveSupportInstrumentation
+  end
+end

data/lib/rom/ldap/extensions/compatibility.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rom/ldap/functions'
+
+module ROM
+  module LDAP
+    # Assign the formatting proc used to rename the Directory::Entry attributes.
+    #
+    use_formatter Functions[:to_method_name]
+  end
+end

data/lib/rom/ldap/extensions/dsml.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'rom/initializer'
+require 'libxml'
+
+module ROM
+  module LDAP
+    #
+    # Directory Service Markup Language (DSML)
+    #
+    # Refines Array and Hash with #to_dsml method.
+    #
+    # @see https://publib.boulder.ibm.com/tividd/td/ITIM/SC32-1149-01/en_US/HTML/Policy_Org_Admin395.htm
+    # @see Directory::Entry
+    # @see Relation::Exporting
+    #
+    module DSML
+      # Export Entry objects as DSML files.
+      #
+      # @param tuple [Entry]
+      #
+      # @api private
+      class Exporter
+
+        extend Initializer
+
+        include LibXML
+
+        # Dataset
+        #
+        param :tuples, type: Types::Strict::Array.of(Types::Strict::Hash)
+
+        #   <?xml version="1.0" encoding="UTF-8"?>
+        #   <dsml>
+        #     <directory-entries>
+        #       <entry dn="dn">
+        #
+        # @return [String]
+        #
+        # @api private
+        def to_dsml
+          doc = XML::Document.new
+          doc.encoding = XML::Encoding::UTF_8
+          doc.root = root = create_node('dsml')
+          root << (entries = create_node('directory-entries'))
+          map_tuples { |entry| entries << entry }
+          doc.to_s
+        end
+
+        private
+
+        # <entry dn="dn">
+        #
+        # @yield [LibXML::XML::Node]
+        #
+        def map_tuples
+          tuples.each do |tuple|
+            next if tuple.empty?
+
+            dn   = tuple.delete('dn')
+            objc = tuple.delete('objectClass')
+
+            entry_node = create_node('entry', dn: dn&.first)
+
+            classes(objc) { |c| entry_node << c }
+
+            attributes(tuple) { |a| entry_node << a }
+
+            yield(entry_node)
+          end
+        end
+
+        # Returns "<objectclass/>" if param is nil
+        #
+        # <oc-value>inetOrgPerson</oc-value>
+        #
+        # @param [Array, Nil] values
+        #
+        # @yield [LibXML::XML::Node]
+        #
+        def classes(values)
+          class_node = create_node('objectclass')
+          values.to_a.each do |value|
+            value_node = create_node('oc-value')
+            value_node.content = value
+            class_node << value_node
+          end
+          yield(class_node)
+        end
+
+        # @example
+        #
+        #   {'cn'=>['Peter']}
+        #     => <attr name="cn"><value>Peter</value></attr>
+        #
+        # @yield [LibXML::XML::Node]
+        #
+        def attributes(attrs)
+          attrs.each do |attr_name, attr_values|
+            attr_node = create_node('attr', name: attr_name)
+            attr_values.each do |value|
+              value_node = create_node('value')
+              value_node.content = value
+              attr_node << value_node
+            end
+            yield(attr_node)
+          end
+        end
+
+        #
+        # @return [LibXML::XML::Node]
+        #
+        def create_node(type, params = EMPTY_OPTS)
+          node = XML::Node.new(type)
+          unless params.empty?
+            params.each do |key, value|
+              XML::Attr.new(node, key.to_s, value.to_s)
+            end
+          end
+          node
+        end
+
+      end
+
+      # Extend functionality of Hash class.
+      #
+      refine ::Hash do
+        # Convert hash to DSML format
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_dsml
+          Exporter.new([self]).to_dsml
+        end
+      end
+
+      # Extend functionality of Array class.
+      #
+      refine ::Array do
+        # Convert array to DSML format
+        #
+        # @return [String]
+        #
+        # @api public
+        def to_dsml
+          Exporter.new(self).to_dsml
+        end
+      end
+    end
+
+    module DSMLExport
+      using DSML
+      #
+      # @return [String]
+      #
+      # @api public
+      def to_dsml
+        export.to_dsml
+      end
+    end
+
+    Relation.include DSMLExport
+  end
+end

data/lib/rom/ldap/extensions/msgpack.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'msgpack'
+
+module ROM
+  module LDAP
+    module MsgPackExport
+      # Export the relation as MessagePack Binary
+      #
+      # @return [String]
+      #
+      # @example
+      #   relation.to_msgpack
+      #
+      # @api public
+      def to_msgpack
+        export.to_msgpack
+      end
+    end
+
+    Relation.include MsgPackExport
+  end
+end

data/lib/rom/ldap/extensions/optimised_json.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+module ROM
+  module LDAP
+    module OptimisedJSON
+      # Replace #to_json
+      #
+      # @param _opts [Mixed] compatibility with JSON.generate
+      #
+      # @return [String]
+      #
+      # @example
+      #   relation.to_json
+      #
+      # @api public
+      def to_json(_opts = nil)
+        Oj.generate(export)
+      end
+    end
+
+    Relation.include OptimisedJSON
+  end
+end

data/lib/rom/ldap/extensions/rails_log_subscriber.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support/log_subscriber'
+
+module ROM
+  module LDAP
+    class RailsLogSubscriber < ActiveSupport::LogSubscriber
+
+      def ldap(event)
+        return unless logger.debug?
+
+        payload = event.payload
+
+        name = format('%s (%.1fms)', payload[:name], event.duration)
+        ldap = payload[:ldap].squeeze(' ')
+        binds = payload[:binds].to_a.inspect if payload[:binds]
+
+        if odd?
+          name = color(name, :cyan, true)
+          ldap = color(ldap, nil, true)
+        else
+          name = color(name, :magenta, true)
+        end
+
+        debug "  #{name}  #{ldap}  #{binds}"
+      end
+
+      attr_reader :odd_or_even
+      private :odd_or_even
+      def odd?
+        @odd_or_even = !odd_or_even
+      end
+
+    end
+
+    RailsLogSubscriber.attach_to(:rom)
+  end
+end

data/lib/rom/ldap/formatter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ROM
+  module LDAP
+    # Proc that returns input value.
+    #
+    DEFAULT_FORMATTER = ->(v) { v }
+
+    # Set/Reset the formatting proc
+    #
+    # @param func [Proc] Callable object
+    #
+    def self.use_formatter(func = nil)
+      @formatter = func
+    end
+
+    # @see 'rom/ldap/extensions/compatibility'
+    #
+    # @example
+    #   ROM::LDAP.load_extensions :compatibility
+    #
+    def self.formatter
+      @formatter || DEFAULT_FORMATTER
+    end
+  end
+end

data/lib/rom/ldap/functions.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'dry/transformer/all'
+require 'base64'
+require 'rom/support/inflector'
+
+module ROM
+  module LDAP
+    # @api private
+    module Functions
+      extend Dry::Transformer::Registry
+
+      import Dry::Transformer::Coercions
+      import Dry::Transformer::ArrayTransformations
+      import Dry::Transformer::HashTransformations
+
+      # Build tuple from arguments.
+      #   Translates keys into original schema names and stringify values.
+      #
+      # @param tuple [Hash] input arguments for directory #add and #modify
+      #
+      # @return [Hash]
+      #
+      # @note Directory#add will receive a hash with key :dn
+      #
+      # @api private
+      def self.tuplify(tuple, matrix)
+        fn = t(:rename_keys, matrix) >>
+             t(:map_values, t(:identify_value)) >>
+             t(:map_values, t(:stringify)) >> t(:reject_blank)
+
+        fn.call(tuple)
+      end
+
+      # remove keys with blank values
+      # nil values allow attribute to be deleted
+      #
+      def self.reject_blank(tuple)
+        tuple.reject { |_k, v| v&.empty? }
+      end
+
+      # Map from
+      #
+      # @todo Finish documentation
+      #
+      # @param val [Symbol,String]
+      #
+      # @example
+      #   id_value(true) => 'TRUE'
+      #   id_value('TRUE') => true
+      #   id_value('peter hamilton') => 'peter hamilton'
+      #
+      # @return [Mixed]
+      #
+      # @api private
+      def self.identify_value(val)
+        case val
+        when ::Symbol, ::TrueClass, ::FalseClass, ::NilClass
+          VALUES_MAP.fetch(val, val)
+        else
+          VALUES_MAP.invert.fetch(val, val)
+        end
+      end
+
+      # Ensure tuple values are strings or nil
+      #
+      # @param value [Mixed]
+      #
+      # @return [String, NilClass]
+      #
+      # @api private
+      def self.stringify(value)
+        case value
+        when ::Numeric    then value.to_s
+        when ::Enumerable then value.map(&:to_s)
+        when ::Hash       then value.to_json
+        when ::String     then value
+        else
+          value
+        end
+      end
+
+      # Compare Magic Bytes
+      #
+      # @see https://en.wikipedia.org/wiki/List_of_file_signatures
+      # @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types
+      # @see https://github.com/sdsykes/fastimage/blob/master/lib/fastimage.rb
+      #
+      # @param value [String] UTF-8 encoded
+      #
+      def self.mime_type(value)
+        mime =
+          case value[0, 2]
+          when "\xFF\xD8".b
+            'image/jpeg'
+          when "\x89P".b
+            'image/png'
+          when 'BM'
+            'image/bitmap'
+          when 'II', 'MM'
+            'image/tiff'
+          when "\xFF\xFBID".b
+            'audio/mpeg'
+          when 'WA'
+            'audio/x-wav'
+          else
+            'application/octet-stream'
+          end
+        to_base64(value).prepend("data:#{mime};base64,")
+      end
+
+      # Base64 encoded string, with optional new line characters.
+      #
+      # @return [String]
+      #
+      def self.to_base64(value, strict: true)
+        if strict
+          Base64.strict_encode64(value).chomp
+        else
+          # [value].pack('m').chomp
+          Base64.encode64(value).chomp
+        end
+      end
+
+      #
+      #
+      # @return [Boolean]
+      #
+      def self.to_boolean(value)
+        Dry::Transformer::Coercions::BOOLEAN_MAP.fetch(value.to_s.downcase)
+      end
+
+      # The 18-digit Active Directory timestamps, also named
+      # 'Windows NT time format','Win32 FILETIME or SYSTEMTIME' or 'NTFS file time'.
+      #
+      # These are used in Microsoft Active Directory for
+      # pwdLastSet, accountExpires, LastLogon, LastLogonTimestamp and LastPwdSet.
+      #
+      # The number of 100-nanoseconds intervals since 12:00 A.M. January 1st, 1601 (UTC).
+      # NB:
+      #   1 nanosecond = a billionth of a second
+      #   Accurate to the nearest millisecond (7 digits)
+      #
+      # @see ROM::LDAP::Types::Time
+      # @see https://ldapwiki.com/wiki/Microsoft%20TIME
+      #
+      # @param value [String] time or integer
+      #
+      # @return [Time] UTC formatted
+      #
+      def self.to_time(value)
+        unix_epoch_time = (Integer(value) / TEN_MILLION) - SINCE_1601
+        ::Time.at(unix_epoch_time).utc
+      rescue ArgumentError
+        ::Time.parse(value).utc
+      end
+
+      # @return [Array<String>]
+      #
+      def self.map_to_base64(values)
+        t(:map_array, t(:to_base64)).call(values)
+      end
+
+      # @return [Array<Integer>]
+      #
+      def self.map_to_integers(tuples)
+        t(:map_array, t(:to_integer)).call(tuples)
+      end
+
+      # @return [Array<Symbol>]
+      #
+      def self.map_to_symbols(tuples)
+        t(:map_array, t(:to_symbol)).call(tuples)
+      end
+
+      # @return [Array<TrueClass, FalseClass>]
+      #
+      def self.map_to_booleans(values)
+        t(:map_array, t(:to_boolean)).call(values)
+      end
+
+      # @return [Array<Time>]
+      #
+      def self.map_to_times(values)
+        t(:map_array, t(:to_time)).call(values)
+      end
+
+      # Convert string to snake case.
+      #
+      # @param value [String]
+      #
+      # @return [String]
+      #
+      def self.to_underscore(value)
+        Inflector.underscore(value.delete('= '))
+      end
+
+      # Function applied to Directory::Entry to format incoming attribute names.
+      #
+      # @api public
+      def self.to_method_name(value)
+        fn = t(:to_string) >> t(:to_underscore) >> t(:to_symbol)
+        fn.call(value)
+      end
+    end
+  end
+end