scim2-filter 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e97f1535209f959f102bff6a8d05ab2b0be5284f99482a34bcdfe36030c949b
+  data.tar.gz: b69d559219489bfdd64a90af1c6cbc8bbb86576514d83ab985da04ddb0250dee
+SHA512:
+  metadata.gz: 4aee232a4ffb1bc1a6138d96702d10c7d53face887c05522671d2079fef7e87846b1db9cbc184e976100094de729b0d38cb7db9d5b473db94811c96f4d51fe9e
+  data.tar.gz: 1f1af70c8fbb720e9b8b38ecc95b9d4e33cc5d7565393852598c661ca6770e35dd17a34b0fec24dc4f2ea9474fea74adddf5091e04bf5d8e021f937c5077200f

data/README.md

@@ -0,0 +1,38 @@
+# SCIM2 Filter
+
+* README:         https://github.com/david-mccullars/scim2-filter
+* Documentation:  http://www.rubydoc.info/github/david-mccullars/scim2-filter
+* Bug Reports:    https://github.com/david-mccullars/scim2-filter/issues
+
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/scim2-filter.svg)](https://badge.fury.io/rb/scim2-filter)
+[![Travis Build Status](https://travis-ci.org/david-mccullars/scim2-filter.svg?branch=master)](https://travis-ci.org/david-mccullars/scim2-filter)
+[![Code Climate](https://codeclimate.com/github/david-mccullars/scim2-filter/badges/gpa.svg)](https://codeclimate.com/github/david-mccullars/scim2-filter)
+
+
+## Description
+
+
+## Features
+
+
+## Installation
+
+```
+gem install scim2-filter
+```
+
+## Requirements
+
+
+## Usage
+
+
+## License
+
+MIT. See the {file:LICENSE} file.
+
+
+## References

data/lib/scim2-filter.rb

@@ -0,0 +1 @@
+require_relative 'scim2'

data/lib/scim2.rb

@@ -0,0 +1,8 @@
+##
+# Scim2 module documentation
+#
+module Scim2
+
+  autoload :Filter,  'scim2/filter'
+
+end

data/lib/scim2/filter.rb

@@ -0,0 +1,23 @@
+module Scim2
+  ##
+  #
+  # RFC7644 SCIM (System for Cross-domain Identity Management) 2.0 defines
+  # mechanisms to query resources.  This includes an optional `filter` parameter
+  # which allows for comprehensive filtering of resources based on various
+  # criteria.  The structure and syntax for the `filter` parameter is defined in
+  # Section 3.4.2.2 of RFC7644.  This module contains classes to support the
+  # validation and parsing of the `filter` parameter as well as its translation
+  # into Arel nodes for use in querying a database.
+  #
+  # @see https://tools.ietf.org/html/rfc7644#section-3.4.2.2
+  ##
+  module Filter
+
+    autoload :ArelHandler,        'scim2/filter/arel_handler'
+    autoload :Lexer,              'scim2/filter/lexer'
+    autoload :NoOpHandler,        'scim2/filter/no_op_handler'
+    autoload :Parser,             'scim2/filter/parser'
+    autoload :SimpleHandler,      'scim2/filter/simple_handler'
+
+  end
+end

data/lib/scim2/filter/arel_handler.rb

@@ -0,0 +1,125 @@
+module Scim2
+  module Filter
+    ##
+    # Implementation of parser handler which translates SCIM 2.0 filters into AREL.
+    # In order to do this, instances of this class will need to be passed the mapping
+    # of attribute names to columns/AREL.
+    #
+    # @example
+    #   # userName sw "J"
+    #
+    #   mapping = {
+    #     userName: User.arel_table[:name],
+    #   }
+    #
+    #   # "users"."name" LIKE 'J%'
+    #
+    # @example
+    #   # urn:ietf:params:scim:schemas:core:2.0:User:userType ne "Employee" and not (emails.value co "example.com" or emails.value co "example.org")
+    #
+    #   mapping = {
+    #     userType: User.arel_table[:type],
+    #     emails: {
+    #       value: User.arel_table[:email],
+    #     },
+    #   }
+    #
+    #   # "users"."type" != 'Employee' AND NOT ("users"."email" LIKE '%example.com' OR "users"."email" LIKE '%example.org%')
+    #
+    # @note Nested filters (e.g. `emails[type eq "work"]` are not supported at this
+    #       time and will result in an `ArgumentError`
+    ##
+    class ArelHandler
+
+      attr_reader :arel_mapping
+
+      def initialize(arel_mapping)
+        @arel_mapping = arel_mapping
+      end
+
+      # Handle NOT filters (e.g. `not (color eq "red")`)
+      # @param filter [Hash<Symbol, Object>] the internal filter being NOT'ed
+      # @return [Hash<Symbol, Object>]
+      def on_not_filter(filter, context:)
+        filter.not
+      end
+
+      # Handle basic attribute comparison filters (e.g. `preference.color eq "red"`)
+      # @param attribute_path [Array<Symbol>] the attribute name(s) being filtered on, split by `.`
+      # @param value [Object] the value being compared against
+      # @param op [Object] the comparison operator (e.g. `:eq`)
+      # @param schema [String] schema namespace of the attribute
+      # @return [Hash<Symbol, Object>]
+      def on_attribute_filter(attribute_path, value, context:, op:, schema: nil)
+        arel = lookup_arel(attribute_path)
+        case op
+        when :eq
+          arel.eq(value)
+        when :ne
+          arel.not_eq(value)
+        when :co
+          arel.matches("%#{value}%")
+        when :sw
+          arel.matches("#{value}%")
+        when :ew
+          arel.matches("%#{value}")
+        when :gt
+          arel.gt(value)
+        when :ge
+          arel.gteq(value)
+        when :lt
+          arel.lt(value)
+        when :le
+          arel.lteq(value)
+        when :pr
+          arel.not_eq(nil)
+        else
+          raise Racc::ParseError, "invalid attribute operand #{op.inspect} with argument #{value.inspect}"
+        end
+      end
+
+      # Handle logical filters (e.g. `name.givenName sw "D" AND title co "VP"`)
+      # @param filter1 [Hash<Symbol, Object>] the left-hand side filter
+      # @param filter2 [Hash<Symbol, Object>] the right-hand side filter
+      # @param op [Object] the logical operator (e.g. `AND`)
+      # @return [Hash<Symbol, Object>]
+      def on_logical_filter(filter1, filter2, context:, op:)
+        case op
+        when :and
+          filter1.and(filter2)
+        when :or
+          filter1.or(filter2)
+        else
+          raise Racc::ParseError, "invalid logical operand #{op.inspect}"
+        end
+      end
+
+      # Handle nested filters (e.g. `emails[type eq "work"]`)
+      # @param attribute_path [Array<Symbol>] the attribute name(s) being filtered on, split by `.`
+      # @param filter [Hash<Symbol, Object>] the nested filter inside the backets
+      # @param schema [String] schema namespace of the attribute
+      # @return [Hash<Symbol, Object>]
+      def on_nested_filter(attribute_path, filter, context:, schema: nil)
+        raise ArgumentError, 'Nested attributes are not currently supported for AREL'
+      end
+
+      protected
+
+      # Looks up the arel object from the mapping according to the given attribute path
+      # @param attribute_path [Array<Symbol>] the attribute name(s) being filtered on, split by `.`
+      # @return [Object] the object returned by the mapping
+      def lookup_arel(attribute_path)
+        arel = arel_mapping.dig(*attribute_path)
+        case arel
+        when NilClass
+          raise ArgumentError, "Attribute #{attribute_path.join(',').inspect} not found in mapping"
+        when Arel::Predications
+          arel
+        else
+          raise ArgumentError, "Mapping for attribute #{attribute_path.join(',').inspect} is not a valid arel object"
+        end
+      end
+
+    end
+  end
+end

data/lib/scim2/filter/lexer.rb

@@ -0,0 +1,15 @@
+require_relative 'lexer.rex'
+
+module Scim2
+  module Filter
+    ##
+    # Implements a SCIM2 compliant lexer for query filters.
+    # This class is responsible for producing and emitting
+    # tokens for consumption by a parser.  It is not
+    # intended to use directly.
+    ##
+    class Lexer < ::Racc::Parser
+
+    end
+  end
+end

data/lib/scim2/filter/lexer.rex

@@ -0,0 +1,65 @@
+class Scim2::Filter::Lexer
+
+macro
+  EQ                [eE][qQ]
+  NE                [nN][eE]
+  GT                [gG][tT]
+  GE                [gG][eE]
+  LT                [lL][tT]
+  LE                [lL][eE]
+  CO                [cC][oO]
+  SW                [sS][wW]
+  EW                [eE][wW]
+  PR                [pP][rR]
+
+  AND               [aA][nN][dD]
+  OR                [oO][rR]
+  NOT               [nN][oO][tT]
+
+  LPAREN            \(
+  RPAREN            \)
+  LBRACKET          \[
+  RBRACKET          \]
+  COLON             :
+  DOT               \.
+
+  DIGIT             \d
+  ALPHA             [a-zA-Z]
+  NAMECHAR          [a-zA-Z0-9_-]
+  SCHEMACHAR        [a-zA-Z0-9:\._-]
+  ESCAPEDSTR        "(?:[^"\\]|\\.)*"
+
+rule
+  # Attribute Operators
+  \s{EQ}\s          { [:EQ, :eq] }
+  \s{NE}\s          { [:NE, :ne] }
+  \s{GT}\s          { [:GT, :gt] }
+  \s{GE}\s          { [:GE, :ge] }
+  \s{LT}\s          { [:LT, :lt] }
+  \s{LE}\s          { [:LE, :le] }
+  \s{CO}\s          { [:CO, :co] }
+  \s{SW}\s          { [:SW, :sw] }
+  \s{EW}\s          { [:EW, :ew] }
+  \s{PR}            { [:PR, :pr] }
+
+  # Logical Operators
+  \s{AND}\s         { [:AND, :and] }
+  \s{OR}\s          { [:OR, :or] }
+  {NOT}\s*          { [:NOT, :not] }  # NOTE: RFC7644 (Section 3.4.2) seems to specify no space, but the example contradicts it
+
+  # Grouping Operators
+  {LPAREN}          { [:LPAREN, text] }
+  {RPAREN}          { [:RPAREN, text] }
+  {LBRACKET}        { [:LBRACKET, text] }
+  {RBRACKET}        { [:RBRACKET, text] }
+
+  # Other
+  null                                  { [:NULL, nil] }
+  (?:true|false)                        { [:BOOLEAN, text == 'true'] }
+  {DIGIT}+                              { [:NUMBER, text.to_i] }
+  {ESCAPEDSTR}                          { [:STRING, text.undump] }
+  ({ALPHA}+{COLON}{SCHEMACHAR}+){COLON} { [:SCHEMA, @ss.captures.first] }
+  {ALPHA}{NAMECHAR}*                    { [:ATTRNAME, text.to_sym] }
+  {DOT}                                 { [:DOT, text] }
+
+end

data/lib/scim2/filter/lexer.rex.rb

@@ -0,0 +1,144 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.7
+# from lexical definition file "lib/scim2/filter/lexer.rex".
+#++
+
+require 'racc/parser'
+class Scim2::Filter::Lexer < Racc::Parser
+      require 'strscan'
+
+      class ScanError < StandardError ; end
+
+      attr_reader   :lineno
+      attr_reader   :filename
+      attr_accessor :state
+
+      def scan_setup(str)
+        @ss = StringScanner.new(str)
+        @lineno =  1
+        @state  = nil
+      end
+
+      def action
+        yield
+      end
+
+      def scan_str(str)
+        scan_setup(str)
+        do_parse
+      end
+      alias :scan :scan_str
+
+      def load_file( filename )
+        @filename = filename
+        File.open(filename, "r") do |f|
+          scan_setup(f.read)
+        end
+      end
+
+      def scan_file( filename )
+        load_file(filename)
+        do_parse
+      end
+
+
+        def next_token
+          return if @ss.eos?
+
+          # skips empty actions
+          until token = _next_token or @ss.eos?; end
+          token
+        end
+
+        def _next_token
+          text = @ss.peek(1)
+          @lineno  +=  1  if text == "\n"
+          token = case @state
+            when nil
+          case
+                  when (text = @ss.scan(/\s[eE][qQ]\s/))
+                     action { [:EQ, :eq] }
+
+                  when (text = @ss.scan(/\s[nN][eE]\s/))
+                     action { [:NE, :ne] }
+
+                  when (text = @ss.scan(/\s[gG][tT]\s/))
+                     action { [:GT, :gt] }
+
+                  when (text = @ss.scan(/\s[gG][eE]\s/))
+                     action { [:GE, :ge] }
+
+                  when (text = @ss.scan(/\s[lL][tT]\s/))
+                     action { [:LT, :lt] }
+
+                  when (text = @ss.scan(/\s[lL][eE]\s/))
+                     action { [:LE, :le] }
+
+                  when (text = @ss.scan(/\s[cC][oO]\s/))
+                     action { [:CO, :co] }
+
+                  when (text = @ss.scan(/\s[sS][wW]\s/))
+                     action { [:SW, :sw] }
+
+                  when (text = @ss.scan(/\s[eE][wW]\s/))
+                     action { [:EW, :ew] }
+
+                  when (text = @ss.scan(/\s[pP][rR]/))
+                     action { [:PR, :pr] }
+
+                  when (text = @ss.scan(/\s[aA][nN][dD]\s/))
+                     action { [:AND, :and] }
+
+                  when (text = @ss.scan(/\s[oO][rR]\s/))
+                     action { [:OR, :or] }
+
+                  when (text = @ss.scan(/[nN][oO][tT]\s*/))
+                     action { [:NOT, :not] }  # NOTE: RFC7644 (Section 3.4.2) seems to specify no space, but the example contradicts it
+
+                  when (text = @ss.scan(/\(/))
+                     action { [:LPAREN, text] }
+
+                  when (text = @ss.scan(/\)/))
+                     action { [:RPAREN, text] }
+
+                  when (text = @ss.scan(/\[/))
+                     action { [:LBRACKET, text] }
+
+                  when (text = @ss.scan(/\]/))
+                     action { [:RBRACKET, text] }
+
+                  when (text = @ss.scan(/null/))
+                     action { [:NULL, nil] }
+
+                  when (text = @ss.scan(/(?:true|false)/))
+                     action { [:BOOLEAN, text == 'true'] }
+
+                  when (text = @ss.scan(/\d+/))
+                     action { [:NUMBER, text.to_i] }
+
+                  when (text = @ss.scan(/"(?:[^"\\]|\\.)*"/))
+                     action { [:STRING, text.undump] }
+
+                  when (text = @ss.scan(/([a-zA-Z]+:[a-zA-Z0-9:\._-]+):/))
+                     action { [:SCHEMA, @ss.captures.first] }
+
+                  when (text = @ss.scan(/[a-zA-Z][a-zA-Z0-9_-]*/))
+                     action { [:ATTRNAME, text.to_sym] }
+
+                  when (text = @ss.scan(/\./))
+                     action { [:DOT, text] }
+
+          
+          else
+            text = @ss.string[@ss.pos .. -1]
+            raise  ScanError, "can not match: '" + text + "'"
+          end  # if
+
+        else
+          raise  ScanError, "undefined state: '" + state.to_s + "'"
+        end  # case state
+          token
+        end  # def _next_token
+
+end # class

data/lib/scim2/filter/no_op_handler.rb

@@ -0,0 +1,27 @@
+module Scim2
+  module Filter
+    ##
+    # A no-op handler implementation which does nothing with parse events.  Its
+    # primary is for validation where the parsed data is not needed.
+    ##
+    class NoOpHandler
+
+      # Handle NOT filters (e.g. `not (color eq "red")`)
+      # @return [NilClass]
+      def on_not_filter(filter, context:); end
+
+      # Handle basic attribute comparison filters (e.g. `preference.color eq "red"`)
+      # @return [NilClass]
+      def on_attribute_filter(attribute_path, value, context:, op:, schema: nil); end
+
+      # Handle logical filters (e.g. `name.givenName sw "D" AND title co "VP"`)
+      # @return [NilClass]
+      def on_logical_filter(filter1, filter2, context:, op:); end
+
+      # Handle sub filters (e.g. `emails[type eq "work"]`)
+      # @return [NilClass]
+      def on_nested_filter(attribute_path, filter, context:, schema: nil); end
+
+    end
+  end
+end

data/lib/scim2/filter/parser.racc

@@ -0,0 +1,108 @@
+class Scim2::Filter::Parser
+
+token EQ NE GT GE LT LE CO SW EW PR AND OR NOT LPAREN RPAREN LBRACKET RBRACKET
+token NULL BOOLEAN NUMBER STRING ATTRNAME SCHEMA DOT
+
+rule
+  #
+  # We must separate OR and AND filter rules in order to ensure the order of operations
+  # is properly followed.  Specifically, the following two filters are the same:
+  #
+  #   w AND x OR y AND z
+  #   (w AND x) OR (y AND z)
+  #
+  # Separating the rules the parser will aggressively gobble up AND rules first, leaving
+  # OR rules for the very last as it bubbles back up the recursion stack
+  #
+  filter
+    : non_or_filter
+    | filter OR non_or_filter
+        {
+          filter1, op, filter2 = val
+          result = handler.on_logical_filter(filter1, filter2, op: op, context: result)
+        }
+
+  non_or_filter
+    : non_boolean_filter
+    | non_or_filter AND non_boolean_filter
+        {
+          filter1, op, filter2 = val
+          result = handler.on_logical_filter(filter1, filter2, op: op, context: result)
+        }
+
+  non_boolean_filter
+    : attribute_filter
+    | nested_filter
+    | grouped_filter
+    | not_filter
+
+  attribute_filter
+    : attr_path PR
+        {
+          attr, op = val
+          result = handler.on_attribute_filter(attr[:path], nil, op: op, schema: attr[:schema], context: result)
+        }
+    | attr_path comp_op comp_value
+        {
+          attr, op, v = val
+          result = handler.on_attribute_filter(attr[:path], v, op: op, schema: attr[:schema], context: result)
+        }
+
+  nested_filter
+    : attr_path LBRACKET filter RBRACKET
+      {
+        attr, _, filter, _ = val
+        result = handler.on_nested_filter(attr[:path], filter, schema: attr[:schema], context: result)
+      }
+
+  grouped_filter
+    : LPAREN filter RPAREN
+      {
+        result = val[1]
+      }
+
+  not_filter
+    : NOT grouped_filter
+      {
+        _, filter = val
+        result = handler.on_not_filter(filter, context: result)
+      }
+
+  attr_path
+    : SCHEMA attr_path_elements
+        {
+          schema, path = val
+          result = { schema: schema, path: path }
+        }
+    | attr_path_elements
+        {
+          result = { path: val.last }
+        }
+
+  attr_path_elements
+    : attr_path_elements DOT ATTRNAME
+        {
+          result = [*val.first, val.last]
+        }
+    | ATTRNAME
+        {
+          result = [val.last]
+        }
+
+  comp_op
+    : EQ
+    | NE
+    | GT
+    | GE
+    | LT
+    | LE
+    | CO
+    | SW
+    | EW
+
+  comp_value
+    : BOOLEAN
+    | NULL
+    | NUMBER
+    | STRING
+end

data/lib/scim2/filter/parser.rb

@@ -0,0 +1,43 @@
+require_relative 'parser.tab'
+
+module Scim2
+  module Filter
+    ##
+    # Implements a SCIM2 compliant event-based parser for query filters.  The parser
+    # will emit four different events to a handler implemention as it encounters
+    # various components within the filter.  For reference, see:
+    #
+    # * {SimpleHandler#on_not_filter}
+    # * {SimpleHandler#on_attribute_filter}
+    # * {SimpleHandler#on_logical_filter}
+    # * {SimpleHandler#on_nested_filter}
+    ##
+    class Parser < ::Racc::Parser
+
+      attr_reader :handler
+
+      # @param handler <Handler> a handler object that responds to all four events
+      def initialize(handler = SimpleHandler.new)
+        super()
+        @handler = handler
+      end
+
+      # Required by {::Racc::Parser} to emit the next token to the parser.  This
+      # method should generally not be called directly.
+      # @return <String> the next token
+      def next_token
+        @lexer.next_token
+      end
+
+      # Parses a given string input
+      # @param string <String> the filter to parse
+      # @return <Object> returns the last object emitted by the handler
+      def parse(string)
+        @lexer = Lexer.new
+        @lexer.scan_setup(string)
+        do_parse
+      end
+
+    end
+  end
+end

data/lib/scim2/filter/parser.tab.rb

@@ -0,0 +1,327 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.5.2
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+module Scim2
+  module Filter
+    class Parser < Racc::Parser
+##### State transition tables begin ###
+
+racc_action_table = [
+    20,    21,    22,    23,    24,    25,    26,    27,    28,    17,
+    14,    10,     9,    16,     9,    19,    10,     9,    10,     9,
+    13,    11,    13,    15,    32,    13,    11,    13,    11,    10,
+     9,    10,     9,    38,    37,    39,    40,    15,    13,    11,
+    13,    11,    44,    15,    33,    32,    42,    43,    16 ]
+
+racc_action_check = [
+     8,     8,     8,     8,     8,     8,     8,     8,     8,     8,
+     1,     0,     0,     2,    10,     8,     9,     9,    15,    15,
+     0,     0,    11,     1,    12,     9,     9,    15,    15,    16,
+    16,    19,    19,    18,    18,    18,    18,    41,    16,    16,
+    19,    19,    41,    29,    14,    31,    29,    32,    34 ]
+
+racc_action_pointer = [
+    -3,    10,     1,   nil,   nil,   nil,   nil,   nil,    -2,     2,
+    -1,    -1,    -1,   nil,    44,     4,    15,   nil,    14,    17,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    30,
+   nil,    20,    24,   nil,    36,   nil,   nil,   nil,   nil,   nil,
+   nil,    24,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -31,   -31,    -1,    -3,    -5,    -6,    -7,    -8,   -31,   -31,
+   -31,   -31,   -15,   -17,   -31,   -31,   -31,    -9,   -31,   -31,
+   -18,   -19,   -20,   -21,   -22,   -23,   -24,   -25,   -26,   -31,
+   -13,   -14,   -31,    45,    -2,    -4,   -10,   -27,   -28,   -29,
+   -30,   -31,   -12,   -16,   -11 ]
+
+racc_goto_table = [
+     1,    34,    35,    30,    18,    36,    31,   nil,   nil,    29,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    41 ]
+
+racc_goto_check = [
+     1,     2,     3,     6,     9,    10,    11,   nil,   nil,     1,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     1 ]
+
+racc_goto_pointer = [
+   nil,     0,   -14,   -14,   nil,   nil,    -7,   nil,   nil,    -4,
+   -13,    -5 ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,     4,     5,     6,     7,     8,   nil,
+   nil,    12 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 27, :_reduce_none,
+  3, 27, :_reduce_2,
+  1, 28, :_reduce_none,
+  3, 28, :_reduce_4,
+  1, 29, :_reduce_none,
+  1, 29, :_reduce_none,
+  1, 29, :_reduce_none,
+  1, 29, :_reduce_none,
+  2, 30, :_reduce_9,
+  3, 30, :_reduce_10,
+  4, 31, :_reduce_11,
+  3, 32, :_reduce_12,
+  2, 33, :_reduce_13,
+  2, 34, :_reduce_14,
+  1, 34, :_reduce_15,
+  3, 37, :_reduce_16,
+  1, 37, :_reduce_17,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 35, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none ]
+
+racc_reduce_n = 31
+
+racc_shift_n = 45
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :EQ => 2,
+  :NE => 3,
+  :GT => 4,
+  :GE => 5,
+  :LT => 6,
+  :LE => 7,
+  :CO => 8,
+  :SW => 9,
+  :EW => 10,
+  :PR => 11,
+  :AND => 12,
+  :OR => 13,
+  :NOT => 14,
+  :LPAREN => 15,
+  :RPAREN => 16,
+  :LBRACKET => 17,
+  :RBRACKET => 18,
+  :NULL => 19,
+  :BOOLEAN => 20,
+  :NUMBER => 21,
+  :STRING => 22,
+  :ATTRNAME => 23,
+  :SCHEMA => 24,
+  :DOT => 25 }
+
+racc_nt_base = 26
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "EQ",
+  "NE",
+  "GT",
+  "GE",
+  "LT",
+  "LE",
+  "CO",
+  "SW",
+  "EW",
+  "PR",
+  "AND",
+  "OR",
+  "NOT",
+  "LPAREN",
+  "RPAREN",
+  "LBRACKET",
+  "RBRACKET",
+  "NULL",
+  "BOOLEAN",
+  "NUMBER",
+  "STRING",
+  "ATTRNAME",
+  "SCHEMA",
+  "DOT",
+  "$start",
+  "filter",
+  "non_or_filter",
+  "non_boolean_filter",
+  "attribute_filter",
+  "nested_filter",
+  "grouped_filter",
+  "not_filter",
+  "attr_path",
+  "comp_op",
+  "comp_value",
+  "attr_path_elements" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 20)
+  def _reduce_2(val, _values, result)
+              filter1, op, filter2 = val
+          result = handler.on_logical_filter(filter1, filter2, op: op, context: result)
+
+    result
+  end
+.,.,
+
+# reduce 3 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 28)
+  def _reduce_4(val, _values, result)
+              filter1, op, filter2 = val
+          result = handler.on_logical_filter(filter1, filter2, op: op, context: result)
+
+    result
+  end
+.,.,
+
+# reduce 5 omitted
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+# reduce 8 omitted
+
+module_eval(<<'.,.,', 'parser.racc', 41)
+  def _reduce_9(val, _values, result)
+              attr, op = val
+          result = handler.on_attribute_filter(attr[:path], nil, op: op, schema: attr[:schema], context: result)
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 46)
+  def _reduce_10(val, _values, result)
+              attr, op, v = val
+          result = handler.on_attribute_filter(attr[:path], v, op: op, schema: attr[:schema], context: result)
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 53)
+  def _reduce_11(val, _values, result)
+            attr, _, filter, _ = val
+        result = handler.on_nested_filter(attr[:path], filter, schema: attr[:schema], context: result)
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 60)
+  def _reduce_12(val, _values, result)
+            result = val[1]
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 66)
+  def _reduce_13(val, _values, result)
+            _, filter = val
+        result = handler.on_not_filter(filter, context: result)
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 73)
+  def _reduce_14(val, _values, result)
+              schema, path = val
+          result = { schema: schema, path: path }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 78)
+  def _reduce_15(val, _values, result)
+              result = { path: val.last }
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 84)
+  def _reduce_16(val, _values, result)
+              result = [*val.first, val.last]
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.racc', 88)
+  def _reduce_17(val, _values, result)
+              result = [val.last]
+
+    result
+  end
+.,.,
+
+# reduce 18 omitted
+
+# reduce 19 omitted
+
+# reduce 20 omitted
+
+# reduce 21 omitted
+
+# reduce 22 omitted
+
+# reduce 23 omitted
+
+# reduce 24 omitted
+
+# reduce 25 omitted
+
+# reduce 26 omitted
+
+# reduce 27 omitted
+
+# reduce 28 omitted
+
+# reduce 29 omitted
+
+# reduce 30 omitted
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+    end   # class Parser
+  end   # module Filter
+end   # module Scim2

data/lib/scim2/filter/simple_handler.rb

@@ -0,0 +1,109 @@
+module Scim2
+  module Filter
+    ##
+    # Reference implementation of parser handler which captures parsed filters into a deeply nested Hash structure.
+    #
+    # @example
+    #   # userName sw "J"
+    #
+    #   {
+    #     sw: {
+    #       path:   [:userName],
+    #       schema: nil,
+    #       value:  'J',
+    #     },
+    #   }
+    #
+    # @example
+    #   # urn:ietf:params:scim:schemas:core:2.0:User:userType ne "Employee" and not (emails.value co "example.com" or emails.value co "example.org")
+    #
+    #   {
+    #     and: [
+    #       {
+    #         ne: {
+    #           path:   [:userType],
+    #           schema: 'urn:ietf:params:scim:schemas:core:2.0:User',
+    #           value:  'Employee',
+    #         },
+    #       },
+    #       {
+    #         not: {
+    #           or: [
+    #             {
+    #               co: {
+    #                 path:   %i[emails value],
+    #                 schema: nil,
+    #                 value:  'example.com',
+    #               },
+    #             },
+    #             {
+    #               co: {
+    #                 path:   %i[emails value],
+    #                 schema: nil,
+    #                 value:  'example.org',
+    #               },
+    #             },
+    #           ],
+    #         },
+    #       },
+    #     ],
+    #   }
+    #
+    # @example
+    #   # emails[type eq "work"]
+    #
+    #   {
+    #     path:   [:emails],
+    #     schema: nil,
+    #     nested: {
+    #       eq: {
+    #         path:   [:type],
+    #         schema: nil,
+    #         value:  'work',
+    #       },
+    #     },
+    #   }
+    #
+    # @note This handler is intended only as a reference implementation for custom
+    #       handlers and is otherwise not designed for production use.
+    ##
+    class SimpleHandler
+
+      # Handle NOT filters (e.g. `not (color eq "red")`)
+      # @param filter [Hash<Symbol, Object>] the internal filter being NOT'ed
+      # @return [Hash<Symbol, Object>]
+      def on_not_filter(filter, context:)
+        { not: filter }
+      end
+
+      # Handle basic attribute comparison filters (e.g. `preference.color eq "red"`)
+      # @param attribute_path [Array<Symbol>] the attribute name(s) being filtered on, split by `.`
+      # @param value [Object] the value being compared against
+      # @param op [Object] the comparison operator (e.g. `:eq`)
+      # @param schema [String] schema namespace of the attribute
+      # @return [Hash<Symbol, Object>]
+      def on_attribute_filter(attribute_path, value, context:, op:, schema: nil)
+        { op => { path: attribute_path, value: value, schema: schema } }
+      end
+
+      # Handle logical filters (e.g. `name.givenName sw "D" AND title co "VP"`)
+      # @param filter1 [Hash<Symbol, Object>] the left-hand side filter
+      # @param filter2 [Hash<Symbol, Object>] the right-hand side filter
+      # @param op [Object] the logical operator (e.g. `AND`)
+      # @return [Hash<Symbol, Object>]
+      def on_logical_filter(filter1, filter2, context:, op:)
+        { op => [filter1, filter2] }
+      end
+
+      # Handle nested filters (e.g. `emails[type eq "work"]`)
+      # @param attribute_path [Array<Symbol>] the attribute name(s) being filtered on, split by `.`
+      # @param filter [Hash<Symbol, Object>] the nested-filter inside the backets
+      # @param schema [String] schema namespace of the attribute
+      # @return [Hash<Symbol, Object>]
+      def on_nested_filter(attribute_path, filter, context:, schema: nil)
+        { path: attribute_path, nested: filter, schema: schema }
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: scim2-filter
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- David McCullars
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rexical
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  RFC7644 SCIM (System for Cross-domain Identity Management) 2.0 filter parser.
+  See https://tools.ietf.org/html/rfc7644#section-3.4.2.2
+
+  This gem implements a filter syntax parser as well as an optional integration
+  for integrating the filter with an Arel table.
+email: david.mccullars@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/scim2-filter.rb
+- lib/scim2.rb
+- lib/scim2/filter.rb
+- lib/scim2/filter/arel_handler.rb
+- lib/scim2/filter/lexer.rb
+- lib/scim2/filter/lexer.rex
+- lib/scim2/filter/lexer.rex.rb
+- lib/scim2/filter/no_op_handler.rb
+- lib/scim2/filter/parser.racc
+- lib/scim2/filter/parser.rb
+- lib/scim2/filter/parser.tab.rb
+- lib/scim2/filter/simple_handler.rb
+homepage: https://github.com/david-mccullars/scim2-filter
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Parser for SCIM query filters
+test_files: []