authentik.sources.scim.patch.lexer

  1from dataclasses import dataclass
  2from enum import Enum
  3
  4from authentik.sources.scim.constants import (
  5    SCIM_URN_GROUP,
  6    SCIM_URN_SCHEMA,
  7    SCIM_URN_USER,
  8    SCIM_URN_USER_ENTERPRISE,
  9)
 10
 11
 12# Token types for SCIM path parsing
 13class TokenType(Enum):
 14    ATTRIBUTE = "ATTRIBUTE"
 15    DOT = "DOT"
 16    LBRACKET = "LBRACKET"
 17    RBRACKET = "RBRACKET"
 18    LPAREN = "LPAREN"
 19    RPAREN = "RPAREN"
 20    STRING = "STRING"
 21    NUMBER = "NUMBER"
 22    BOOLEAN = "BOOLEAN"
 23    NULL = "NULL"
 24    OPERATOR = "OPERATOR"
 25    AND = "AND"
 26    OR = "OR"
 27    NOT = "NOT"
 28    EOF = "EOF"
 29
 30
 31@dataclass
 32class Token:
 33    type: TokenType
 34    value: str
 35    position: int = 0
 36
 37
 38class SCIMPathLexer:
 39    """Lexer for SCIM paths and filter expressions"""
 40
 41    OPERATORS = ["eq", "ne", "co", "sw", "ew", "gt", "lt", "ge", "le", "pr"]
 42
 43    def __init__(self, text: str):
 44        self.schema_urns = [
 45            SCIM_URN_SCHEMA,
 46            SCIM_URN_GROUP,
 47            SCIM_URN_USER,
 48            SCIM_URN_USER_ENTERPRISE,
 49        ]
 50        self.text = text
 51        self.pos = 0
 52        self.current_char = self.text[self.pos] if self.pos < len(self.text) else None
 53
 54    def advance(self):
 55        """Move to next character"""
 56        self.pos += 1
 57        self.current_char = self.text[self.pos] if self.pos < len(self.text) else None
 58
 59    def skip_whitespace(self):
 60        """Skip whitespace characters"""
 61        while self.current_char and self.current_char.isspace():
 62            self.advance()
 63
 64    def read_string(self, quote_char):
 65        """Read a quoted string"""
 66        value = ""
 67        self.advance()  # Skip opening quote
 68
 69        while self.current_char and self.current_char != quote_char:
 70            if self.current_char == "\\":
 71                self.advance()
 72                if self.current_char:
 73                    value += self.current_char
 74                    self.advance()
 75            else:
 76                value += self.current_char
 77                self.advance()
 78
 79        if self.current_char == quote_char:
 80            self.advance()  # Skip closing quote
 81
 82        return value
 83
 84    def read_number(self):
 85        """Read a number (integer or float)"""
 86        value = ""
 87        while self.current_char and (self.current_char.isdigit() or self.current_char == "."):
 88            value += self.current_char
 89            self.advance()
 90        return value
 91
 92    def read_identifier(self):
 93        """Read an identifier (attribute name or operator) - supports URN format"""
 94        value = ""
 95        while self.current_char and (self.current_char.isalnum() or self.current_char in "_-:"):
 96            value += self.current_char
 97            self.advance()
 98            # If the identifier value so far is a schema URN, take that as the identifier and
 99            # treat the next part as a sub_attribute
100            if value in self.schema_urns:
101                self.current_char = "."
102                return value
103
104            # Handle dots within URN identifiers (like "2.0")
105            # A dot is part of the identifier if it's followed by a digit
106            if (
107                self.current_char == "."
108                and self.pos + 1 < len(self.text)
109                and self.text[self.pos + 1].isdigit()
110            ):
111                value += self.current_char
112                self.advance()
113                # Continue reading digits after the dot
114                while self.current_char and self.current_char.isdigit():
115                    value += self.current_char
116                    self.advance()
117
118        return value
119
120    def get_next_token(self) -> Token:  # noqa PLR0911
121        """Get the next token from the input"""
122        while self.current_char:
123            if self.current_char.isspace():
124                self.skip_whitespace()
125                continue
126
127            if self.current_char == ".":
128                self.advance()
129                return Token(TokenType.DOT, ".")
130
131            if self.current_char == "[":
132                self.advance()
133                return Token(TokenType.LBRACKET, "[")
134
135            if self.current_char == "]":
136                self.advance()
137                return Token(TokenType.RBRACKET, "]")
138
139            if self.current_char == "(":
140                self.advance()
141                return Token(TokenType.LPAREN, "(")
142
143            if self.current_char == ")":
144                self.advance()
145                return Token(TokenType.RPAREN, ")")
146
147            if self.current_char in "\"'":
148                quote_char = self.current_char
149                value = self.read_string(quote_char)
150                return Token(TokenType.STRING, value)
151
152            if self.current_char.isdigit():
153                value = self.read_number()
154                return Token(TokenType.NUMBER, value)
155
156            if self.current_char.isalpha() or self.current_char == "_":
157                value = self.read_identifier()
158
159                # Check for special keywords
160                if value.lower() == "true":
161                    return Token(TokenType.BOOLEAN, True)
162                elif value.lower() == "false":
163                    return Token(TokenType.BOOLEAN, False)
164                elif value.lower() == "null":
165                    return Token(TokenType.NULL, None)
166                elif value.lower() == "and":
167                    return Token(TokenType.AND, "and")
168                elif value.lower() == "or":
169                    return Token(TokenType.OR, "or")
170                elif value.lower() == "not":
171                    return Token(TokenType.NOT, "not")
172                elif value.lower() in self.OPERATORS:
173                    return Token(TokenType.OPERATOR, value.lower())
174                else:
175                    return Token(TokenType.ATTRIBUTE, value)
176
177            # Skip unknown characters
178            self.advance()
179
180        return Token(TokenType.EOF, "")