ruby-rego 0.1.0

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Ruby
+  module Rego
+    module AST
+      # Represents a query literal with optional with modifiers.
+      class QueryLiteral < Base
+        # @param expression [Object]
+        # @param with_modifiers [Array<WithModifier>]
+        # @param location [Location, nil]
+        def initialize(expression:, with_modifiers: [], location: nil)
+          super(location: location)
+          @expression = expression
+          @with_modifiers = with_modifiers.dup.freeze
+        end
+
+        # @return [Object]
+        attr_reader :expression
+
+        # @return [Array<WithModifier>]
+        attr_reader :with_modifiers
+      end
+
+      # Represents a `some` declaration.
+      class SomeDecl < Base
+        # @param variables [Array<Variable>]
+        # @param collection [Object, nil]
+        # @param location [Location, nil]
+        def initialize(variables:, collection: nil, location: nil)
+          super(location: location)
+          @variables = variables.dup.freeze
+          @collection = collection
+        end
+
+        # @return [Array<Variable>]
+        attr_reader :variables
+
+        # @return [Object, nil]
+        attr_reader :collection
+      end
+
+      # Represents a `with` modifier.
+      class WithModifier < Base
+        # @param target [Object]
+        # @param value [Object]
+        # @param location [Location, nil]
+        def initialize(target:, value:, location: nil)
+          super(location: location)
+          @target = target
+          @value = value
+        end
+
+        # @return [Object]
+        attr_reader :target
+
+        # @return [Object]
+        attr_reader :value
+      end
+    end
+  end
+end

data/lib/ruby/rego/ast/reference.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Ruby
+  module Rego
+    module AST
+      # Represents a reference to nested data (e.g. input.user.roles[0]).
+      class Reference < Base
+        # @param base [Object]
+        # @param path [Array<RefArg>]
+        # @param location [Location, nil]
+        def initialize(base:, path:, location: nil)
+          super(location: location)
+          @base = base
+          @path = path.dup.freeze
+        end
+
+        # @return [Object]
+        attr_reader :base
+
+        # @return [Array<RefArg>]
+        attr_reader :path
+      end
+
+      # Base class for reference path arguments.
+      class RefArg < Base
+        # @param value [Object]
+        # @param location [Location, nil]
+        def initialize(value:, location: nil)
+          super(location: location)
+          @value = value
+        end
+
+        # @return [Object]
+        attr_reader :value
+      end
+
+      # Dot-based reference argument (e.g. .foo).
+      class DotRefArg < RefArg
+        # @param value [Object]
+        # @param location [Location, nil]
+        def initialize(value:, location: nil)
+          super
+        end
+      end
+
+      # Bracket-based reference argument (e.g. [0]).
+      class BracketRefArg < RefArg
+        # @param value [Object]
+        # @param location [Location, nil]
+        def initialize(value:, location: nil)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/ast/rule.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Ruby
+  module Rego
+    module AST
+      # Represents a rule definition.
+      class Rule < Base
+        RULE_TYPE_LOOKUP = %i[rule_type type kind].freeze
+
+        # Bundles rule components for storage.
+        Definition = Struct.new(:head, :body, :default_value, :else_clause, keyword_init: true)
+
+        # @param name [String]
+        # @param head [Object, nil]
+        # @param body [Object, nil]
+        # @param default_value [Object, nil]
+        # @param else_clause [Object, nil]
+        # @param location [Location, nil]
+        # :reek:LongParameterList
+        def initialize(name:, head: nil, body: nil, default_value: nil, else_clause: nil, location: nil) # rubocop:disable Metrics/ParameterLists
+          super(location: location)
+          @name = name
+          @definition = Definition.new(
+            head: head,
+            body: body,
+            default_value: default_value,
+            else_clause: else_clause
+          )
+        end
+
+        # @return [String]
+        attr_reader :name
+
+        # @return [Object, nil]
+        def head
+          definition.head
+        end
+
+        # @return [Object, nil]
+        def body
+          definition.body
+        end
+
+        # @return [Object, nil]
+        def default_value
+          definition.default_value
+        end
+
+        # @return [Object, nil]
+        def else_clause
+          definition.else_clause
+        end
+
+        # @return [Boolean]
+        def complete?
+          rule_type == :complete
+        end
+
+        # @return [Boolean]
+        def partial_set?
+          rule_type == :partial_set
+        end
+
+        # @return [Boolean]
+        def partial_object?
+          rule_type == :partial_object
+        end
+
+        # @return [Boolean]
+        def function?
+          rule_type == :function
+        end
+
+        private
+
+        # @return [Symbol, nil]
+        def rule_type
+          return nil unless head
+
+          type = resolve_rule_type
+
+          type.is_a?(String) ? type.to_sym : type
+        end
+
+        def resolve_rule_type
+          type_from_object || type_from_hash
+        end
+
+        # :reek:ManualDispatch
+        def type_from_object
+          RULE_TYPE_LOOKUP.each do |method|
+            return head.public_send(method) if head.respond_to?(method)
+          end
+
+          nil
+        end
+
+        def type_from_hash
+          return nil unless head.is_a?(Hash)
+
+          RULE_TYPE_LOOKUP.each do |key|
+            return head[key] if head.key?(key)
+          end
+
+          nil
+        end
+
+        attr_reader :definition
+      end
+    end
+  end
+end

data/lib/ruby/rego/ast/unary_op.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Ruby
+  module Rego
+    module AST
+      # Represents a unary operation (e.g. negation).
+      class UnaryOp < Base
+        OPERATORS = %i[not minus].freeze
+
+        # @param operator [Symbol]
+        # @param operand [Object]
+        # @param location [Location, nil]
+        def initialize(operator:, operand:, location: nil)
+          @operator = operator
+          validate_operator!
+          super(location: location)
+          @operand = operand
+        end
+
+        # @return [Symbol]
+        attr_reader :operator
+
+        # @return [Object]
+        attr_reader :operand
+
+        private
+
+        def validate_operator # rubocop:disable Naming/PredicateMethod
+          OPERATORS.include?(@operator)
+        end
+
+        def validate_operator!
+          return if validate_operator
+
+          raise ArgumentError, "Unknown unary operator: #{@operator.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/ast/variable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Ruby
+  module Rego
+    module AST
+      # Represents a variable identifier.
+      class Variable < Base
+        # @param name [String]
+        # @param location [Location, nil]
+        def initialize(name:, location: nil)
+          super(location: location)
+          @name = name
+        end
+
+        # @return [String]
+        attr_reader :name
+      end
+    end
+  end
+end

data/lib/ruby/rego/ast.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "ast/base"
+require_relative "ast/literal"
+require_relative "ast/variable"
+require_relative "ast/reference"
+require_relative "ast/binary_op"
+require_relative "ast/unary_op"
+require_relative "ast/composite"
+require_relative "ast/comprehension"
+require_relative "ast/every"
+require_relative "ast/query"
+require_relative "ast/call"
+require_relative "ast/module"
+require_relative "ast/package"
+require_relative "ast/import"
+require_relative "ast/rule"

data/lib/ruby/rego/builtins/aggregates.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+
+module Ruby
+  module Rego
+    module Builtins
+      # Built-in aggregation helpers.
+      module Aggregates
+        AGGREGATE_FUNCTIONS = {
+          "count" => :count,
+          "sum" => :sum,
+          "max" => :max,
+          "min" => :min,
+          "all" => :all,
+          "any" => :any
+        }.freeze
+
+        # @return [Ruby::Rego::Builtins::BuiltinRegistry]
+        def self.register!
+          registry = BuiltinRegistry.instance
+
+          AGGREGATE_FUNCTIONS.each do |name, handler|
+            register_function(registry, name, handler)
+          end
+
+          registry
+        end
+
+        def self.register_function(registry, name, handler)
+          return if registry.registered?(name)
+
+          registry.register(name, 1) { |value| public_send(handler, value) }
+        end
+        private_class_method :register_function
+
+        # @param collection [Ruby::Rego::Value]
+        # @return [Ruby::Rego::NumberValue]
+        def self.count(collection)
+          Base.assert_type(
+            collection,
+            expected: [ArrayValue, ObjectValue, SetValue, StringValue],
+            context: "count"
+          )
+
+          NumberValue.new(collection.value.size)
+        end
+
+        # @param array [Ruby::Rego::Value]
+        # @return [Ruby::Rego::NumberValue]
+        def self.sum(array)
+          numbers = numeric_array(array, name: "sum")
+          NumberValue.new(numbers.sum)
+        end
+
+        # @param array [Ruby::Rego::Value]
+        # @return [Ruby::Rego::NumberValue]
+        def self.max(array)
+          numbers = numeric_array(array, name: "max")
+          ensure_non_empty(numbers, name: "max")
+          NumberValue.new(numbers.max)
+        end
+
+        # @param array [Ruby::Rego::Value]
+        # @return [Ruby::Rego::NumberValue]
+        def self.min(array)
+          numbers = numeric_array(array, name: "min")
+          ensure_non_empty(numbers, name: "min")
+          NumberValue.new(numbers.min)
+        end
+
+        # @param array [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.all(array)
+          Base.assert_type(array, expected: ArrayValue, context: "all")
+          BooleanValue.new(array.value.all?(&:truthy?))
+        end
+
+        # @param array [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.any(array)
+          Base.assert_type(array, expected: ArrayValue, context: "any")
+          BooleanValue.new(array.value.any?(&:truthy?))
+        end
+
+        # @param array [Ruby::Rego::Value]
+        # @param name [String]
+        # @return [Array<Numeric>]
+        def self.numeric_array(array, name:)
+          Base.assert_type(array, expected: ArrayValue, context: name)
+
+          array.value.map.with_index do |element, index|
+            Base.assert_type(
+              element,
+              expected: NumberValue,
+              context: "#{name} element #{index}"
+            )
+            element.value
+          end
+        end
+        private_class_method :numeric_array
+
+        # @param numbers [Array<Numeric>]
+        # @param name [String]
+        # @return [void]
+        def self.ensure_non_empty(numbers, name:)
+          return unless numbers.empty?
+
+          raise Ruby::Rego::BuiltinArgumentError.new(
+            "Expected a non-empty array",
+            expected: "non-empty array",
+            actual: numbers.size,
+            context: name,
+            location: nil
+          )
+        end
+        private_class_method :ensure_non_empty
+      end
+    end
+  end
+end
+
+Ruby::Rego::Builtins::Aggregates.register!

data/lib/ruby/rego/builtins/base.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+require_relative "../value"
+
+module Ruby
+  module Rego
+    module Builtins
+      # Shared helpers for built-in function implementations.
+      module Base
+        # @param args [Array<Object>]
+        # @param expected [Integer, Array<Integer>]
+        # @param name [String, nil]
+        # @return [void]
+        def self.assert_arity(args, expected, name: nil)
+          actual = args.size
+          return if arity_valid?(actual, expected)
+
+          raise_builtin_arity_error(actual, expected, name)
+        end
+
+        # @param value [Object]
+        # @param expected [Class, Array<Class>]
+        # @param context [String, nil]
+        # @return [void]
+        def self.assert_type(value, expected:, context: nil)
+          expected_classes = normalize_expected(expected)
+          return if expected_classes.any? { |klass| value.is_a?(klass) }
+
+          raise_type_error(
+            expected: expected_classes.map(&:name).join(" or "),
+            actual: value.class.name,
+            context: context
+          )
+        end
+
+        # @param value [Object]
+        # @return [Object]
+        def self.to_ruby(value)
+          value.is_a?(Ruby::Rego::Value) ? value.to_ruby : value
+        end
+
+        # @param value [Object]
+        # @return [Ruby::Rego::Value]
+        def self.to_value(value)
+          Ruby::Rego::Value.from_ruby(value)
+        end
+
+        def self.normalize_expected(expected)
+          expected.is_a?(Array) ? expected : [expected]
+        end
+        private_class_method :normalize_expected
+
+        def self.normalize_arity(expected)
+          expected.is_a?(Array) ? expected : [expected]
+        end
+        private_class_method :normalize_arity
+
+        def self.format_arity(expected_list)
+          expected_list.map(&:to_i).uniq.sort.join(" or ")
+        end
+        private_class_method :format_arity
+
+        def self.arity_valid?(actual, expected)
+          normalize_arity(expected).include?(actual)
+        end
+        private_class_method :arity_valid?
+
+        def self.raise_builtin_arity_error(actual, expected, name)
+          context = name ? "builtin #{name}" : nil
+          expected_list = normalize_arity(expected)
+          raise Ruby::Rego::BuiltinArgumentError.new(
+            "Wrong number of arguments",
+            expected: format_arity(expected_list),
+            actual: actual,
+            context: context,
+            location: nil
+          )
+        end
+        private_class_method :raise_builtin_arity_error
+
+        def self.raise_type_error(expected:, actual:, context: nil)
+          raise Ruby::Rego::BuiltinArgumentError.new(
+            "Type mismatch",
+            expected: expected,
+            actual: actual,
+            context: context,
+            location: nil
+          )
+        end
+        private_class_method :raise_type_error
+      end
+    end
+  end
+end

data/lib/ruby/rego/builtins/collections/array_ops.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../numeric_helpers"
+require_relative "../../errors"
+require_relative "../../value"
+
+module Ruby
+  module Rego
+    module Builtins
+      module Collections
+        # Array-focused collection helpers.
+        module ArrayOps
+          # @param array [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ArrayValue]
+          def self.sort(array)
+            elements = array_values(array, name: "sort")
+            return ArrayValue.new([]) if elements.empty?
+
+            ensure_uniform_sort_type(elements)
+            sorted = elements.sort_by(&:to_ruby)
+            ArrayValue.new(sorted)
+          end
+
+          # @param left [Ruby::Rego::Value]
+          # @param right [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ArrayValue]
+          def self.array_concat(left, right)
+            left_values = array_values(left, name: "array.concat left")
+            right_values = array_values(right, name: "array.concat right")
+            ArrayValue.new(left_values + right_values)
+          end
+
+          # @param array [Ruby::Rego::Value]
+          # @param start [Ruby::Rego::Value]
+          # @param stop [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ArrayValue]
+          def self.array_slice(array, start, stop)
+            elements = array_values(array, name: "array.slice array")
+            start_index, stop_index = slice_indices(start, stop)
+            ArrayValue.new(slice_elements(elements, start_index, stop_index))
+          end
+
+          def self.array_values(value, name:)
+            Base.assert_type(value, expected: ArrayValue, context: name)
+            value.value
+          end
+          private_class_method :array_values
+
+          def self.ensure_uniform_sort_type(elements)
+            type = sort_type(elements)
+            elements.drop(1).each_with_index do |element, index|
+              validate_sort_element(element, type, index + 1)
+            end
+          end
+          private_class_method :ensure_uniform_sort_type
+
+          def self.sort_type(elements)
+            first = elements.first
+            Base.assert_type(first, expected: [NumberValue, StringValue], context: "sort element 0")
+            first.class
+          end
+          private_class_method :sort_type
+
+          def self.validate_sort_element(element, type, index)
+            Base.assert_type(element, expected: [NumberValue, StringValue], context: "sort element #{index}")
+            return if element.is_a?(type)
+
+            raise_sort_type_error(type, element.class)
+          end
+          private_class_method :validate_sort_element
+
+          def self.raise_sort_type_error(expected_type, actual_type)
+            raise Ruby::Rego::BuiltinArgumentError.new(
+              "Mixed types cannot be sorted",
+              expected: expected_type.name,
+              actual: actual_type.name,
+              context: "sort",
+              location: nil
+            )
+          end
+          private_class_method :raise_sort_type_error
+
+          def self.slice_indices(start, stop)
+            [
+              NumericHelpers.non_negative_integer(start, context: "array.slice start"),
+              NumericHelpers.non_negative_integer(stop, context: "array.slice stop")
+            ]
+          end
+          private_class_method :slice_indices
+
+          def self.slice_elements(elements, start_index, stop_index)
+            length = stop_index - start_index
+            return [] if length <= 0 || start_index >= elements.length
+
+            elements.slice(start_index, length) || []
+          end
+          private_class_method :slice_elements
+        end
+      end
+    end
+  end
+end