ruby-rego 0.1.0

data/lib/ruby/rego/lexer/template_string_reader.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Template string lexer helpers.
+    class Lexer
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def read_template_string
+        start = capture_position
+        advance
+        return read_raw_template_string(start) if current_char == "`"
+
+        read_standard_template_string(start)
+      end
+
+      def read_standard_template_string(start)
+        advance
+        buffer = +""
+
+        until eof?
+          char_position = capture_position
+          char = advance
+          return build_token(TokenType::TEMPLATE_STRING, buffer, start) if char == "\""
+
+          break if char == "\n"
+
+          if char == "\\" && current_char == "{"
+            advance
+            buffer << TEMPLATE_ESCAPE
+            next
+          end
+
+          buffer << (char == "\\" ? read_escape_sequence(char_position) : char)
+        end
+
+        raise_unterminated_string(start)
+      end
+
+      def read_raw_template_string(start)
+        advance
+        buffer = +""
+
+        until eof?
+          char = advance
+          return build_token(TokenType::RAW_TEMPLATE_STRING, buffer, start) if char == "`"
+
+          if char == "\\" && current_char == "{"
+            advance
+            buffer << TEMPLATE_ESCAPE
+          else
+            buffer << char
+          end
+        end
+
+        raise_unterminated_raw_string(start)
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/ruby/rego/lexer.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "location"
+require_relative "token"
+require_relative "lexer/number_reader"
+require_relative "lexer/stream"
+require_relative "lexer/string_reader"
+require_relative "lexer/template_string_reader"
+
+module Ruby
+  module Rego
+    # Converts Rego source code into a stream of tokens.
+    # rubocop:disable Metrics/ClassLength
+    class Lexer
+      KEYWORDS = {
+        "package" => TokenType::PACKAGE,
+        "import" => TokenType::IMPORT,
+        "as" => TokenType::AS,
+        "default" => TokenType::DEFAULT,
+        "if" => TokenType::IF,
+        "contains" => TokenType::CONTAINS,
+        "some" => TokenType::SOME,
+        "in" => TokenType::IN,
+        "every" => TokenType::EVERY,
+        "not" => TokenType::NOT,
+        "and" => TokenType::AND,
+        "or" => TokenType::OR,
+        "with" => TokenType::WITH,
+        "else" => TokenType::ELSE,
+        "true" => TokenType::TRUE,
+        "false" => TokenType::FALSE,
+        "null" => TokenType::NULL,
+        "data" => TokenType::DATA,
+        "input" => TokenType::INPUT
+      }.freeze
+
+      SINGLE_CHAR_TOKENS = {
+        "(" => TokenType::LPAREN,
+        ")" => TokenType::RPAREN,
+        "[" => TokenType::LBRACKET,
+        "]" => TokenType::RBRACKET,
+        "{" => TokenType::LBRACE,
+        "}" => TokenType::RBRACE,
+        "." => TokenType::DOT,
+        "," => TokenType::COMMA,
+        ";" => TokenType::SEMICOLON,
+        "+" => TokenType::PLUS,
+        "-" => TokenType::MINUS,
+        "*" => TokenType::STAR,
+        "/" => TokenType::SLASH,
+        "%" => TokenType::PERCENT,
+        "|" => TokenType::PIPE,
+        "&" => TokenType::AMPERSAND
+      }.freeze
+
+      COMPOUND_TOKENS = {
+        ":" => [TokenType::COLON, TokenType::ASSIGN],
+        "=" => [TokenType::UNIFY, TokenType::EQ],
+        "!" => [nil, TokenType::NEQ],
+        "<" => [TokenType::LT, TokenType::LTE],
+        ">" => [TokenType::GT, TokenType::GTE]
+      }.freeze
+
+      NEWLINE_CHARS = ["\n", "\r"].freeze
+      WHITESPACE_CHARS = [" ", "\t"].freeze
+      EXPONENT_CHARS = %w[e E].freeze
+      SIGN_CHARS = %w[+ -].freeze
+
+      IDENTIFIER_START = /[A-Za-z_]/
+      IDENTIFIER_PART = /[A-Za-z0-9_]/
+      DIGIT = /\d/
+      HEX_DIGIT = /[0-9A-Fa-f]/
+
+      # Create a lexer for the provided source.
+      #
+      # @param source [String] Rego source code
+      def initialize(source)
+        @source = source.to_s
+        @position = 0
+        @line = 1
+        @column = 1
+        @offset = 0
+      end
+
+      # Tokenize the source into a list of tokens, including EOF.
+      #
+      # @return [Array<Token>] token stream
+      def tokenize
+        # @type var tokens: Array[Token]
+        tokens = []
+
+        loop do
+          skip_whitespace
+          break if eof?
+
+          tokens << next_token
+        end
+
+        tokens << eof_token
+        tokens
+      end
+
+      private
+
+      attr_reader :source, :position, :line, :column, :offset
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def next_token
+        char = current_char
+        return eof_token if char.nil?
+
+        return read_newline if newline?(char)
+        return read_number if digit?(char)
+        return read_identifier if identifier_start?(char)
+        return read_template_string if template_string_start?(char)
+        return read_string if char == "\""
+        return read_raw_string if char == "`"
+
+        raise_error("Invalid number literal", capture_position, length: 1) if char == "." && digit?(peek(1))
+
+        token = simple_token_for(char)
+        return token if token
+
+        token = read_compound_token(char)
+        return token if token
+
+        raise_error("Unexpected character: #{char.inspect}", capture_position, length: 1)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      def eof_token
+        start = capture_position
+        build_token(TokenType::EOF, nil, start)
+      end
+
+      def simple_token_for(char)
+        type = SINGLE_CHAR_TOKENS[char]
+        return nil unless type
+
+        start = capture_position
+        advance
+        build_token(type, nil, start)
+      end
+
+      def read_compound_token(char)
+        config = COMPOUND_TOKENS[char]
+        return nil unless config
+
+        single_type, double_type = config
+        start = capture_position
+        advance
+        return build_token(double_type, nil, start) if match?("=")
+        return build_token(single_type, nil, start) if single_type
+
+        raise_error("Unexpected character: #{char.inspect}", start, length: 1)
+      end
+
+      def skip_whitespace
+        loop do
+          char = current_char
+          break if char.nil?
+
+          if char == "#"
+            skip_comment
+            next
+          end
+
+          break unless whitespace?(char)
+
+          advance
+        end
+      end
+
+      def skip_comment
+        advance
+        advance until eof? || newline?(current_char)
+      end
+
+      def template_string_start?(char)
+        char == "$" && ["\"", "`"].include?(peek(1).to_s)
+      end
+
+      def read_newline
+        start = capture_position
+        advance
+        build_token(TokenType::NEWLINE, "\n", start)
+      end
+
+      def read_identifier
+        start = capture_position
+        buffer = +""
+
+        buffer << advance while identifier_part?(current_char)
+
+        return build_token(TokenType::UNDERSCORE, nil, start) if buffer == "_"
+
+        keyword = KEYWORDS[buffer]
+        return build_token(keyword, nil, start) if keyword
+
+        build_token(TokenType::IDENT, buffer, start)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/ruby/rego/location.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Represents a source location in a Rego policy.
+    #
+    # @example
+    #   location = Ruby::Rego::Location.new(line: 3, column: 12, offset: 42, length: 5)
+    #   location.to_s # => "line 3, column 12, offset 42, length 5"
+    #
+    class Location
+      # Coerce a hash or location into a Location instance.
+      #
+      # @param position [Location, Hash] position data
+      # @return [Location]
+      def self.from(position)
+        return position if position.is_a?(Location)
+
+        new(
+          line: position.fetch(:line),
+          column: position.fetch(:column),
+          offset: position[:offset],
+          length: position[:length]
+        )
+      end
+
+      # Create a new source location.
+      #
+      # @param line [Integer] 1-based line number
+      # @param column [Integer] 1-based column number
+      # @param offset [Integer, nil] 0-based character offset
+      # @param length [Integer, nil] length of the token or span
+      def initialize(line:, column:, offset: nil, length: nil)
+        @line = line
+        @column = column
+        @offset = offset
+        @length = length
+      end
+
+      # Line number.
+      #
+      # @return [Integer]
+      attr_reader :line
+
+      # Column number.
+      #
+      # @return [Integer]
+      attr_reader :column
+
+      # Character offset.
+      #
+      # @return [Integer, nil]
+      attr_reader :offset
+
+      # Length of the token or span.
+      #
+      # @return [Integer, nil]
+      attr_reader :length
+
+      # Convert the location to a readable string.
+      #
+      # @return [String]
+      def to_s
+        {
+          line: line,
+          column: column,
+          offset: offset,
+          length: length
+        }.compact.map { |key, value| "#{key} #{value}" }.join(", ")
+      end
+    end
+  end
+end

data/lib/ruby/rego/memoization.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Shared memoization store for evaluation caches.
+    module Memoization
+      # Holds per-scope caches used during evaluation.
+      class Context
+        def initialize
+          @rule_values = {} # @type var @rule_values: Hash[String, Value]
+          @reference_values = {} # @type var @reference_values: Hash[AST::Reference, Value]
+          @reference_keys = {} # @type var @reference_keys: Hash[AST::Reference, Array[Object] | Object]
+          @function_values = {} # @type var @function_values: Hash[Array[Object], Value]
+        end
+
+        # @return [Hash]
+        attr_reader :rule_values
+
+        # @return [Hash]
+        attr_reader :reference_values
+
+        # @return [Hash]
+        attr_reader :reference_keys
+
+        # @return [Hash]
+        attr_reader :function_values
+      end
+
+      # Stack-based memoization store for nested scopes.
+      class Store
+        def initialize
+          @contexts = [Context.new]
+        end
+
+        # Reset memoized data for a new evaluation.
+        #
+        # @return [void]
+        def reset!
+          @contexts = [Context.new]
+          nil
+        end
+
+        # Reset memoized data without mutation semantics.
+        #
+        # @return [void]
+        def reset
+          reset!
+        end
+
+        # Run with a fresh memoization context.
+        #
+        # @return [Object]
+        def with_context
+          @contexts << Context.new
+          yield
+        ensure
+          @contexts.pop
+        end
+
+        # @return [Context]
+        def context
+          @contexts.last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    # Parsing helpers for collection literals and comprehensions.
+    # :reek:TooManyMethods
+    # :reek:RepeatedConditional
+    # :reek:DataClump
+    # rubocop:disable Metrics/ClassLength
+    class Parser
+      private
+
+      # :reek:TooManyStatements
+      # :reek:DuplicateMethodCall
+      def parse_array
+        start = consume(TokenType::LBRACKET)
+        location = start.location
+        consume_newlines
+        return AST::ArrayLiteral.new(elements: [], location: location) if match?(TokenType::RBRACKET)
+
+        term = parse_expression(Precedence::OR)
+        return parse_array_comprehension(start, term) if pipe_token?
+
+        elements = parse_expression_list_until_with_first(TokenType::RBRACKET, term)
+        consume_newlines
+        consume(TokenType::RBRACKET, "Expected ']' after array literal.")
+        AST::ArrayLiteral.new(elements: elements, location: location)
+      end
+
+      def parse_object(start_token, first_key, first_value)
+        pairs = build_object_pairs(first_key, first_value)
+        consume_newlines
+        consume(TokenType::RBRACE, "Expected '}' after object literal.")
+        AST::ObjectLiteral.new(pairs: pairs, location: start_token.location)
+      end
+
+      def build_object_pairs(first_key, first_value)
+        pairs = [] # @type var pairs: Array[[AST::expression, AST::expression]]
+        pairs << [first_key, first_value]
+        append_object_pairs(pairs)
+        pairs
+      end
+
+      def parse_set(start_token, first_element = nil)
+        return empty_set_literal(start_token) if empty_set?(first_element)
+
+        elements = parse_expression_list_until_with_first(TokenType::RBRACE, first_element)
+        consume_newlines
+        consume(TokenType::RBRACE, "Expected '}' after set literal.")
+        AST::SetLiteral.new(elements: elements, location: start_token.location)
+      end
+
+      # :reek:TooManyStatements
+      def parse_braced_literal
+        start = consume(TokenType::LBRACE)
+        consume_newlines
+        return empty_object_literal(start) if rbrace_token?
+
+        first = parse_expression(Precedence::OR)
+        return parse_set_comprehension(start, first) if pipe_token?
+        return parse_object_literal_or_comprehension(start, first) if match?(TokenType::COLON)
+
+        parse_set(start, first)
+      end
+
+      def parse_object_literal_or_comprehension(start, key)
+        advance
+        consume_newlines
+        value = parse_expression(Precedence::OR)
+        return parse_object_comprehension(start, key, value) if pipe_token?
+
+        parse_object(start, key, value)
+      end
+
+      def parse_expression_list_until(end_token)
+        elements = [] # @type var elements: Array[AST::expression]
+        consume_newlines
+        elements << parse_expression
+        append_expression_list(elements, end_token)
+        elements
+      end
+
+      def parse_expression_list_until_with_first(end_token, first_element)
+        elements = [] # @type var elements: Array[AST::expression]
+        elements << first_element
+        consume_newlines
+        append_expression_list(elements, end_token)
+        elements
+      end
+
+      def parse_object_pair(key)
+        consume(TokenType::COLON, "Expected ':' after object key.")
+        consume_newlines
+        value = parse_expression
+        [key, value]
+      end
+
+      def append_expression_list(elements, end_token)
+        while match?(TokenType::COMMA)
+          advance
+          consume_newlines
+          break if match?(end_token)
+
+          elements << parse_expression
+        end
+      end
+
+      def append_object_pairs(pairs)
+        while match?(TokenType::COMMA)
+          advance
+          consume_newlines
+          break if rbrace_token?
+
+          pairs << parse_object_pair(parse_expression)
+        end
+      end
+
+      def parse_array_comprehension(start_token, term)
+        parse_comprehension(
+          start_token,
+          term,
+          TokenType::RBRACKET,
+          ["Expected '|' after array term.", "Expected ']' after array comprehension."],
+          AST::ArrayComprehension
+        )
+      end
+
+      def parse_object_comprehension(start_token, key, value)
+        parse_comprehension(
+          start_token,
+          [key, value],
+          TokenType::RBRACE,
+          ["Expected '|' after object term.", "Expected '}' after object comprehension."],
+          AST::ObjectComprehension
+        )
+      end
+
+      def parse_set_comprehension(start_token, term)
+        parse_comprehension(
+          start_token,
+          term,
+          TokenType::RBRACE,
+          ["Expected '|' after set term.", "Expected '}' after set comprehension."],
+          AST::SetComprehension
+        )
+      end
+
+      # :reek:LongParameterList
+      def parse_comprehension(start_token, term, end_token, messages, node_class)
+        pipe_message, end_message = messages
+        consume(TokenType::PIPE, pipe_message)
+        body = parse_query(end_token, newline_delimiter: true)
+        consume(end_token, end_message)
+        node_class.new(term: term, body: body, location: start_token.location)
+      end
+
+      def empty_set?(first_element)
+        rbrace_token? && !first_element
+      end
+
+      def empty_object_literal(start_token)
+        advance
+        AST::ObjectLiteral.new(pairs: [], location: start_token.location)
+      end
+
+      def empty_set_literal(start_token)
+        advance
+        AST::SetLiteral.new(elements: [], location: start_token.location)
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end