ruby-rego 0.1.0

data/lib/ruby/rego/parser/expressions.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Parsing helpers for expressions.
+    # rubocop:disable Metrics/ClassLength
+    class Parser
+      private
+
+      def parse_expression(precedence = Precedence::LOWEST)
+        parse_infix_expression(parse_primary, precedence)
+      end
+
+      def parse_infix_expression(left, precedence)
+        return left unless infix_operator?(precedence)
+
+        operator_token = advance
+        parse_infix_expression(parse_infix(left, operator_token), precedence)
+      end
+
+      def infix_operator?(precedence)
+        Helpers.precedence_of(current_token.type) > precedence
+      end
+
+      def parse_primary
+        handler = PRIMARY_PARSERS[current_token.type]
+        return send(handler) if handler
+
+        parse_error("Expected expression.")
+      end
+
+      # :reek:FeatureEnvy
+      def parse_infix(left, operator_token)
+        operator_type = operator_token.type
+        operator = BINARY_OPERATOR_MAP.fetch(operator_type) do
+          parse_error("Unsupported operator: #{operator_type}.")
+        end
+
+        right = parse_expression(Helpers.precedence_of(operator_type))
+        AST::BinaryOp.new(operator: operator, left: left, right: right, location: operator_token.location)
+      end
+
+      # :reek:TooManyStatements
+      def parse_call_args
+        parse_parenthesized_expression_list(
+          open_message: "Expected '('.",
+          close_message: "Expected ')' after arguments."
+        )
+      end
+
+      def parse_string_literal
+        token = current_token
+        parse_error("Expected string literal.") unless [TokenType::STRING, TokenType::RAW_STRING].include?(token.type)
+        advance
+        value = token.value.to_s
+        AST::StringLiteral.new(value: value, location: token.location)
+      end
+
+      def parse_template_string
+        token = current_token
+        unless [TokenType::TEMPLATE_STRING, TokenType::RAW_TEMPLATE_STRING].include?(token.type)
+          parse_error("Expected template string literal.")
+        end
+        advance
+        AST::TemplateString.new(parts: parse_template_parts(token), location: token.location)
+      end
+
+      # :reek:FeatureEnvy
+      def parse_number_literal
+        token = consume(TokenType::NUMBER, "Expected number literal.")
+        value = token.value
+        if value.is_a?(String)
+          value = if value.match?(/[eE.]/)
+                    Float(value)
+                  else
+                    Integer(value, 10)
+                  end
+        end
+        AST::NumberLiteral.new(value: value, location: token.location)
+      end
+
+      def parse_boolean_literal
+        token_type = current_token.type
+        location = current_token.location
+        advance
+        AST::BooleanLiteral.new(value: token_type == TokenType::TRUE, location: location)
+      end
+
+      def parse_null_literal
+        token = advance
+        AST::NullLiteral.new(location: token.location)
+      end
+
+      def parse_unary_expression
+        token = advance
+        operator = UNARY_OPERATOR_MAP.fetch(token.type)
+        operand = parse_expression(Precedence::UNARY)
+        AST::UnaryOp.new(operator: operator, operand: operand, location: token.location)
+      end
+
+      def parse_parenthesized_expression
+        advance
+        expression = parse_parenthesized_body
+        consume(TokenType::RPAREN, "Expected ')' after expression.")
+        expression
+      end
+
+      def parse_parenthesized_body
+        consume_newlines
+        expression = parse_expression
+        consume_newlines
+        expression
+      end
+
+      # :reek:TooManyStatements
+      def parse_parenthesized_expression_list(open_message:, close_message:)
+        consume(TokenType::LPAREN, open_message)
+        consume_newlines
+        args = [] # @type var args: Array[AST::expression]
+        args = parse_expression_list_until(TokenType::RPAREN) unless match?(TokenType::RPAREN)
+        consume_newlines
+        consume(TokenType::RPAREN, close_message)
+        args
+      end
+
+      # :reek:NilCheck
+      # :reek:DuplicateMethodCall
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def parse_template_parts(token)
+        text = token.value.to_s
+        location = token.location
+        parts = [] # @type var parts: Array[Object]
+        index = 0
+
+        while index < text.length
+          start = text.index("{", index)
+          if start.nil?
+            literal = text[index..]
+            append_template_literal(parts, literal, location)
+            break
+          end
+
+          if start > index
+            literal = text[index...start]
+            append_template_literal(parts, literal, location)
+          end
+
+          expr_start = start + 1
+          expr_end = find_template_expression_end(text, expr_start)
+          expr_source = text[expr_start...expr_end]
+          parts << self.class.parse_expression_from_string(expr_source)
+          index = expr_end + 1
+        end
+
+        parts = [AST::StringLiteral.new(value: "", location: location)] if parts.empty?
+        parts
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def append_template_literal(parts, literal, location)
+        literal_value = normalize_template_literal(literal)
+        parts << AST::StringLiteral.new(value: literal_value, location: location)
+      end
+
+      # :reek:UtilityFunction
+      def normalize_template_literal(literal)
+        literal.tr(Lexer::TEMPLATE_ESCAPE, "{")
+      end
+
+      # :reek:TooManyStatements
+      # :reek:FeatureEnvy
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def find_template_expression_end(text, start_index)
+        depth = 0
+        index = start_index
+        in_string = nil
+        escaped = false
+
+        while index < text.length
+          char = text[index]
+          if in_string
+            if escaped
+              escaped = false
+            elsif in_string == "\"" && char == "\\"
+              escaped = true
+            elsif char == in_string
+              in_string = nil
+            end
+            index += 1
+            next
+          end
+
+          if char && ["\"", "`"].include?(char)
+            in_string = char
+            index += 1
+            next
+          end
+
+          if char == "{"
+            depth += 1
+          elsif char == "}"
+            return index if depth.zero?
+
+            depth -= 1
+          end
+
+          index += 1
+        end
+
+        parse_error("Unterminated template expression.")
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ruby/rego/parser/precedence.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../token"
+
+module Ruby
+  module Rego
+    class Parser
+      # Operator precedence table for binary operators.
+      # :reek:TooManyConstants
+      module Precedence
+        LOWEST = 0
+        ASSIGNMENT = 1
+        OR = 2
+        AND = 3
+        EQUALS = 4
+        COMPARE = 5
+        SUM = 6
+        PRODUCT = 7
+        UNARY = 8
+
+        BINARY = {
+          TokenType::ASSIGN => ASSIGNMENT,
+          TokenType::UNIFY => ASSIGNMENT,
+          TokenType::OR => OR,
+          TokenType::AND => AND,
+          TokenType::IN => COMPARE,
+          TokenType::EQ => EQUALS,
+          TokenType::NEQ => EQUALS,
+          TokenType::LT => COMPARE,
+          TokenType::LTE => COMPARE,
+          TokenType::GT => COMPARE,
+          TokenType::GTE => COMPARE,
+          TokenType::PLUS => SUM,
+          TokenType::MINUS => SUM,
+          TokenType::STAR => PRODUCT,
+          TokenType::SLASH => PRODUCT,
+          TokenType::PERCENT => PRODUCT
+        }.freeze
+      end
+    end
+  end
+end

data/lib/ruby/rego/parser/query.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Parsing helpers for queries.
+    class Parser
+      private
+
+      # :reek:TooManyStatements
+      # :reek:DuplicateMethodCall
+      # :reek:BooleanParameter
+      def parse_query(*end_tokens, newline_delimiter: false)
+        terminators = end_tokens.flatten
+        literals = [] # @type var literals: Array[AST::query_literal]
+
+        loop do
+          consume_newlines if newline_delimiter
+          break if terminators.include?(current_token.type)
+
+          literals << parse_literal
+          break if terminators.include?(current_token.type)
+
+          break unless consume_query_separators(newline_delimiter)
+        end
+
+        literals
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # :reek:TooManyStatements
+      # :reek:ControlParameter
+      def consume_query_separators(newline_delimiter)
+        consumed = false
+
+        loop do
+          if match?(TokenType::SEMICOLON)
+            advance
+            consumed = true
+            next
+          end
+
+          if newline_delimiter && newline_token?
+            advance
+            consumed = true
+            next
+          end
+
+          break
+        end
+
+        consumed
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def parse_literal
+        return parse_some_decl if match?(TokenType::SOME)
+
+        expression = parse_expression
+        AST::QueryLiteral.new(
+          expression: expression,
+          with_modifiers: parse_with_modifiers,
+          location: expression.location
+        )
+      end
+
+      def parse_with_modifiers
+        modifiers = [] # @type var modifiers: Array[AST::WithModifier]
+        modifiers << parse_with_modifier while match?(TokenType::WITH)
+        modifiers
+      end
+
+      def parse_some_decl
+        keyword = consume(TokenType::SOME, "Expected 'some' declaration.")
+        variables = parse_some_variables
+        collection = parse_some_collection
+
+        AST::SomeDecl.new(variables: variables, collection: collection, location: keyword.location)
+      end
+
+      # :reek:TooManyStatements
+      def parse_some_variables
+        variables = [] # @type var variables: Array[AST::Variable]
+        loop do
+          variables << parse_variable
+          break unless match?(TokenType::COMMA)
+
+          advance
+        end
+        variables
+      end
+
+      def parse_some_collection
+        return nil unless match?(TokenType::IN)
+
+        advance
+        parse_expression
+      end
+
+      def parse_every
+        keyword = consume(TokenType::EVERY, "Expected 'every' expression.")
+        key_var, value_var = parse_every_variables
+        domain = parse_every_domain
+        body = parse_every_body
+        AST::Every.new(key_var: key_var, value_var: value_var, domain: domain, body: body, location: keyword.location)
+      end
+
+      def parse_every_variables
+        value_var = parse_variable
+        return [nil, value_var] unless match?(TokenType::COMMA)
+
+        advance
+        [value_var, parse_variable]
+      end
+
+      def parse_every_domain
+        consume(TokenType::IN, "Expected 'in' after every variables.")
+        parse_expression
+      end
+
+      # :reek:TooManyStatements
+      def parse_every_body
+        consume_newlines
+        consume(TokenType::LBRACE, "Expected '{' to start every body.")
+        consume_newlines
+        body = parse_query(TokenType::RBRACE, newline_delimiter: true)
+        consume(TokenType::RBRACE, "Expected '}' after every body.")
+        body
+      end
+
+      def parse_with_modifier
+        keyword = consume(TokenType::WITH, "Expected 'with' modifier.")
+        target = parse_expression
+        consume(TokenType::AS, "Expected 'as' after with target.")
+        value = parse_expression
+        AST::WithModifier.new(target: target, value: value, location: keyword.location)
+      end
+    end
+  end
+end

data/lib/ruby/rego/parser/references.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Parsing helpers for references and identifiers.
+    class Parser
+      private
+
+      def parse_reference(base)
+        reference_base, path = Helpers.normalize_reference_base(base)
+        parse_reference_path(path)
+        AST::Reference.new(base: reference_base, path: path, location: base.location)
+      end
+
+      # :reek:TooManyStatements
+      # :reek:DuplicateMethodCall
+      # rubocop:disable Metrics/MethodLength
+      def parse_path(identifier_context)
+        segments = [] # @type var segments: Array[String]
+
+        segments << parse_path_segment(identifier_context)
+
+        loop do
+          if match?(TokenType::DOT)
+            advance
+            segments << parse_path_segment(identifier_context)
+            next
+          end
+
+          segment = parse_bracket_path_segment
+          break unless segment
+
+          segments << segment
+        end
+
+        segments
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def parse_path_segment(identifier_context)
+        token_type = current_token.type
+        return parse_identifier(identifier_context) if identifier_context.allowed_types.include?(token_type)
+
+        parse_error("Expected #{identifier_context.name} identifier.")
+      end
+
+      def parse_bracket_path_segment
+        return nil unless match?(TokenType::LBRACKET)
+        return nil unless bracket_string_segment?
+
+        advance
+        value = parse_string_literal
+        consume(TokenType::RBRACKET, "Expected ']' after path segment.")
+        value.value
+      end
+
+      def bracket_string_segment?
+        return false unless match?(TokenType::LBRACKET)
+
+        token = peek
+        [TokenType::STRING, TokenType::RAW_STRING].include?(token.type)
+      end
+
+      # :reek:TooManyStatements
+      def parse_identifier(identifier_context)
+        context_name = identifier_context.name
+        allowed_types = identifier_context.allowed_types
+        token = current_token
+        token_type = token.type
+
+        parse_error("Expected #{context_name} identifier.") unless allowed_types.include?(token_type)
+
+        advance
+        return token.value.to_s if token_type == TokenType::IDENT
+
+        IDENTIFIER_TOKEN_NAMES.fetch(token_type) { token_type.to_s.downcase }
+      end
+
+      def parse_identifier_expression
+        base = parse_variable
+        base = parse_reference(base) if match?(TokenType::DOT, TokenType::LBRACKET)
+        return base unless match?(TokenType::LPAREN)
+
+        AST::Call.new(name: base, args: parse_call_args, location: base.location)
+      end
+
+      def parse_variable
+        token = current_token
+        name = Helpers.variable_name_for(token)
+        advance
+        AST::Variable.new(name: name, location: token.location)
+      end
+
+      def parse_reference_path(path)
+        while match?(TokenType::DOT, TokenType::LBRACKET)
+          match?(TokenType::DOT) ? parse_dot_reference(path) : parse_bracket_reference(path)
+        end
+      end
+
+      def parse_dot_reference(path)
+        advance
+        segment_token = current_token
+        segment = parse_identifier(IdentifierContext.new(name: "reference", allowed_types: IDENTIFIER_TOKEN_TYPES))
+        path << AST::DotRefArg.new(value: segment, location: segment_token.location)
+      end
+
+      def parse_bracket_reference(path)
+        bracket_token = consume(TokenType::LBRACKET)
+        value = parse_expression
+        consume(TokenType::RBRACKET, "Expected ']' after reference path.")
+        path << AST::BracketRefArg.new(value: value, location: bracket_token.location)
+      end
+    end
+  end
+end