rom-ldap 0.2.2

data/lib/rom/ldap/parsers/filter_syntax.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module ROM
+  module LDAP
+    module Parsers
+      #
+      # Parses a filter into an AST
+      #
+      # @api private
+      class FilterSyntax
+
+        extend Initializer
+
+        param :filter, type: Types::Filter
+
+        param :attributes, type: Types.Array(Types::Hash)
+
+        attr_accessor :result
+
+        def call
+          if open_statement
+            if joined_statement
+              join_type = encode_constructor
+
+              branches = []
+
+              while (branch = call)
+                branches << branch
+              end
+
+              self.result = [join_type, branches]
+
+            elsif negated_statement
+              negator = encode_constructor
+              self.result = [negator, call]
+
+            else
+              skip_whitespace
+              scan_attribute
+              attribute = encode_attribute
+
+              skip_whitespace
+              scan_operator
+              op = encode_operator
+
+              skip_whitespace
+              scan_value
+              value = encode_value
+
+              self.result = [op, attribute, value]
+            end
+
+            close_statement
+
+            result
+          end
+        end
+
+        private
+
+        # @return [StringScanner]
+        #
+        def scanner
+          @scanner ||= StringScanner.new(filter)
+        end
+
+        def skip_whitespace
+          scanner.scan(/\s*/)
+        end
+
+        def close_statement
+          scanner.scan(/\s*\)\s*/)
+        end
+
+        def open_statement
+          scanner.scan(/\s*\(\s*/)
+        end
+
+        # @return [String, NilClass] "!"
+        #
+        def negated_statement
+          scanner.scan(/\s*\!\s*/)
+        end
+
+        # @return [String, NilClass] "&" or "|"
+        #
+        def joined_statement
+          scanner.scan(CONSTRUCTOR_REGEX)
+        end
+
+        def scan_value
+          scanner.scan(VAL_REGEX)
+        end
+
+        def scan_operator
+          scanner.scan(OPERATOR_REGEX)
+        end
+
+        def scan_attribute
+          scanner.scan(/[-\w:.]*[\w]/)
+        end
+
+        # @return [String,Symbol] formatted
+        #
+        def encode_attribute
+          attr = attributes.find { |a| a[:canonical].eql?(scanner.matched) }
+          attr ? attr[:name] : scanner.matched
+        end
+
+        # @return [Mixed]
+        #
+        def encode_value
+          Functions[:identify_value].call(scanner.matched)
+        end
+
+        # @return [Symbol]
+        #
+        def encode_constructor
+          CONSTRUCTORS.invert[scanner.matched]
+        end
+
+        # @return [Symbol]
+        #
+        def encode_operator
+          OPERATORS.invert[scanner.matched]
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/ldap/pdu.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'dry/core/class_attributes'
+require 'rom/initializer'
+
+module ROM
+  module LDAP
+    # @see PDU
+    #
+    # @return [Array<Symbol>]
+    #
+    SUCCESS_CODES = %i[
+      success
+      time_limit_exceeded
+      size_limit_exceeded
+      compare_true
+      compare_false
+      referral
+      sasl_bind_in_progress
+    ].freeze
+
+    # LDAP Message Protocol Data Unit (PDU)
+    #
+    # @api private
+    class PDU
+
+      extend Initializer
+
+      param :message_id, proc(&:to_i), reader: true, type: Types::Strict::Integer
+
+      # @!attribute [r] tag
+      #   @return [Array]
+      param :tag, reader: :private, type: Types::Strict::Array
+
+      param :ctrls, reader: :private, type: Types::Strict::Array, default: -> { EMPTY_ARRAY }
+
+      # @return [Integer]
+      #
+      def app_tag
+        tag.ber_identifier & 0x1f
+      end
+
+      # @return [Integer]
+      #
+      def result_code
+        tag[0]
+      end
+
+      #
+      # @return [String]
+      #
+      def matched_dn
+        tag[1]
+      end
+
+      # @example
+      #   "Matchingrule is required for sorting by the attribute cn"
+      #
+      # @return [String]
+      #
+      def advice
+        tag[2]
+      end
+
+      def search_referrals
+        return unless search_referral?
+
+        tag[3] || EMPTY_ARRAY
+      end
+
+      def result_server_sasl_creds
+        return unless bind_result? && gteq4?
+
+        tag[3]
+      end
+
+      # @return [Array] => [version, username, password]
+      #
+      #
+      def bind_result
+        return unless bind_result?
+        raise ResponseTypeInvalidError, 'Invalid bind_result' unless gteq_3?
+
+        tag
+      end
+
+      #
+      # @return [OpenStruct] => :version, :name, :authentication
+      #
+      def bind_parameters
+        return unless bind_request?
+
+        s = ::OpenStruct.new
+        s.version, s.name, s.authentication = tag
+        s
+      end
+
+      #
+      # @return [OpenStruct, NilClass] => :version, :name, :authentication
+      #
+      def search_parameters
+        return unless search_request?
+
+        s = ::OpenStruct.new
+        s.base_object,
+        s.scope,
+        s.deref_aliases,
+        s.size_limit,
+        s.time_limit,
+        s.types_only,
+        s.filter,
+        s.attributes = tag
+        s
+      end
+
+      # Message
+      #
+      # @example => "No attribute with the name false exists in the server's schema"
+      #
+      # @return [String, NilClass]
+      #
+      def extended_response
+        raise ResponseTypeInvalidError, 'Invalid extended_response' unless gteq_3?
+
+        tag[3] if extended_response?
+      end
+
+      # ["dn", [ entry... ]]
+      #
+      # @return [Array, NilClass]
+      #
+      def search_entry
+        raise ResponseTypeInvalidError, 'Invalid search_entry' unless gteq_2?
+
+        tag if search_result?
+      end
+
+      # RFC-2251, an LDAP 'control' is a sequence of tuples, each consisting of
+      #   - an OID
+      #   - a boolean criticality flag defaulting FALSE
+      #   - and an optional Octet String
+      #
+      # If only two fields are given, the second one may be either criticality
+      # or data, since criticality has a default value. RFC-2696 is a good example.
+      #
+      # @see Connection::Read#search
+      #
+      # @return [Array<OpenStruct>] => :oid, :criticality, :value
+      #
+      def result_controls
+        ctrls.map do |control|
+          oid, level, value = control
+          value, level = level, false if level&.is_a?(String)
+          ::OpenStruct.new(oid: oid, criticality: level, value: value)
+        end
+      end
+
+      # logging =======================  #
+
+      # First item from responses.yaml
+      #
+      # @return [String]
+      #
+      def message
+        detailed_response[0]
+      end
+
+      # Grep for error message
+      #
+      # @return [String, FalseClass]
+      #
+      def error_message
+        tag[3][/comment: (.*), data/, 1] if tag[3]
+      end
+
+      # @return [String]
+      #
+      def info
+        detailed_response[1]
+      end
+
+      # @return [String]
+      #
+      def flag
+        detailed_response[2]
+      end
+
+      # predicates =======================  #
+
+      # @return [Boolean]
+      #
+      def add_response?
+        pdu_type == :add_response
+      end
+
+      # @see https://tools.ietf.org/html/rfc4511#section-4.2.1
+      #
+      # @return [Boolean]
+      #
+      def bind_request?
+        pdu_type == :bind_request
+      end
+
+      # A successful operation is indicated by a BindResponse with a resultCode set to success.
+      #
+      # @see https://tools.ietf.org/html/rfc4511#section-4.2.2
+      #
+      # @return [Boolean]
+      #
+      def bind_result?
+        pdu_type.eql?(:bind_result)
+      end
+
+      # @return [Boolean]
+      #
+      def search_request?
+        pdu_type.eql?(:search_request)
+      end
+
+      # @return [Boolean]
+      #
+      def search_result?
+        pdu_type.eql?(:search_returned_data)
+      end
+
+      # @return [Boolean]
+      #
+      def search_referral?
+        pdu_type == :search_result_referral
+      end
+
+      # @return [Boolean]
+      #
+      def extended_response?
+        pdu_type == :extended_response
+      end
+
+      # @return [Boolean]
+      #
+      def success?
+        SUCCESS_CODES.include?(result_code_symbol)
+      end
+
+      # @return [Boolean]
+      #
+      def failure?
+        !success?
+      end
+
+      # conversion =======================  #
+
+      # @return [Symbol]
+      #
+      def pdu_type
+        BER.fetch(:response, app_tag) || raise(ResponseTypeInvalidError, "Unknown pdu_type: #{app_tag}")
+      end
+
+      # @return [Symbol]
+      #
+      def result_code_symbol
+        BER.fetch(:result, result_code)
+      end
+
+      private
+
+      def detailed_response
+        RESPONSES[result_code_symbol]
+      end
+
+      # @return [Boolean]
+      #
+      def gteq_2?
+        tag.length >= 2
+      end
+
+      # @return [Boolean]
+      #
+      def gteq_3?
+        tag.length >= 3
+      end
+
+    end
+  end
+end

data/lib/rom/ldap/plugin/pagination.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'rom/initializer'
+require 'dry/equalizer'
+
+module ROM
+  module LDAP
+    module Plugin
+      # Pagination plugin for Relations
+      #
+      # @api public
+      module Pagination
+        # Pager object provides the underlying pagination API for relations
+        #
+        # @api public
+        class Pager
+
+          extend Initializer
+
+          # @!parse include Dry::Equalizer
+          include Dry::Equalizer(:dataset, :options)
+
+          # @!attribute [r] dataset
+          #   @return [LDAP::Dataset] Relation's dataset
+          param :dataset
+
+          # @!attribute [r] current_page
+          #   @return [Integer] Current page number
+          option :current_page, default: -> { 1 }
+
+          # @!attribute [r] per_page
+          #   @return [Integer] Current per-page number
+          option :per_page
+
+          # Return next page number
+          #
+          # @example
+          #   users.page(2).pager.next_page
+          #   # => 3
+          #
+          # @return [Integer]
+          #
+          # @api public
+          def next_page
+            num = current_page + 1
+            num if total_pages >= num
+          end
+
+          # Return previous page number
+          #
+          # @example
+          #   users.page(2).pager.prev_page
+          #   # => 1
+          #
+          # @return [Integer]
+          #
+          # @api public
+          def prev_page
+            num = current_page - 1
+            num if num.positive?
+          end
+
+          # Return total number of tuples
+          #
+          # @return [Integer]
+          #
+          # @api public
+          def total
+            dataset.total
+          end
+
+          # Return total number of pages
+          #
+          # @return [Integer]
+          #
+          # @api public
+          def total_pages
+            (total / per_page.to_f).ceil
+          end
+
+          # @api private
+          def at(dataset, current_page, per_page = self.per_page)
+            current_page = current_page.to_i
+            per_page     = per_page.to_i
+            offset       = (current_page - 1) * per_page
+
+            self.class.new(
+              dataset.with(offset: offset, limit: per_page),
+              current_page: current_page, per_page: per_page
+            )
+          end
+
+          alias_method :limit_value, :per_page
+
+        end
+
+        # @api private
+        def self.included(klass)
+          super
+
+          klass.class_eval do
+            defines :per_page
+
+            option :pager, default: -> {
+              Pager.new(dataset, per_page: self.class.per_page)
+            }
+          end
+        end
+
+        # Paginate a relation
+        #
+        # @example
+        #   users.page(1)
+        #   users.pager # => info about pagination
+        #
+        # @return [Relation]
+        #
+        # @api public
+        def page(num)
+          next_pager = pager.at(dataset, num)
+          new(next_pager.dataset, pager: next_pager)
+        end
+
+        # Set limit for pagination
+        #
+        # @example
+        #   users.per_page(10).page(2)
+        #
+        # @return [Relation]
+        #
+        # @api public
+        def per_page(num)
+          next_pager = pager.at(dataset, pager.current_page, num)
+          new(next_pager.dataset, pager: next_pager)
+        end
+      end
+    end
+  end
+end
+
+ROM.plugins do
+  adapter :ldap do
+    register :pagination, ROM::LDAP::Plugin::Pagination, type: :relation
+  end
+end