ruby-rego 0.1.0

data/lib/ruby/rego/with_modifiers/with_modifier_context.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+require_relative "../errors"
+require_relative "../value"
+require_relative "with_modifier_builtin_override"
+require_relative "with_modifier_path_key_resolver"
+require_relative "with_modifier_path_override"
+require_relative "with_modifier_root_scope"
+
+module Ruby
+  module Rego
+    module WithModifiers
+      # Applies a single with modifier in a given environment.
+      class WithModifierContext
+        # @param modifier [WithModifier]
+        # @param environment [Environment]
+        # @param expression_evaluator [Evaluator::ExpressionEvaluator]
+        def initialize(modifier:, environment:, expression_evaluator:)
+          @modifier = modifier
+          @environment = environment
+          @expression_evaluator = expression_evaluator
+        end
+
+        # @yieldparam environment [Environment]
+        # @return [Object]
+        def apply(&)
+          return apply_reference(&) if target.is_a?(AST::Reference)
+          return apply_variable(&) if target.is_a?(AST::Variable)
+
+          raise EvaluationError.new("Unsupported with target: #{target.class}", rule: nil, location: target.location)
+        end
+
+        private
+
+        attr_reader :modifier, :environment, :expression_evaluator
+
+        def target
+          modifier.target
+        end
+
+        def value
+          modifier.value
+        end
+
+        def apply_reference(&)
+          scope = reference_scope
+          overridden = reference_override(scope)
+          return overridden if overridden.is_a?(UndefinedValue)
+
+          scope.with_override(overridden, &)
+        end
+
+        def reference_scope
+          base = target.base
+          location = target.location
+          unless base.is_a?(AST::Variable)
+            raise EvaluationError.new("Unsupported with target base: #{base.class}", rule: nil, location: location)
+          end
+
+          WithModifierRootScope.new(
+            environment: environment,
+            name: base.name,
+            location: location
+          )
+        end
+
+        def reference_override(scope)
+          keys = reference_path_keys
+          return UndefinedValue.new if keys.is_a?(UndefinedValue)
+
+          replacement = resolved_value
+          WithModifierPathOverride.new(
+            base_value: scope.base_value,
+            keys: keys,
+            replacement: replacement,
+            location: target.location
+          ).apply
+        end
+
+        # :reek:TooManyStatements
+        # Returns UndefinedValue when any path key is undefined to short-circuit modifier application.
+        def reference_path_keys
+          resolver = WithModifierPathKeyResolver.new(expression_evaluator: expression_evaluator)
+          keys = target.path.map { |segment| resolver.resolve(segment) }
+          undefined_key = keys.find { |key| key.is_a?(UndefinedValue) }
+          undefined_key || keys
+        end
+
+        def apply_variable(&)
+          name = target.name
+          if WithModifierRootScope::ROOT_NAMES.include?(name)
+            scope = WithModifierRootScope.new(
+              environment: environment,
+              name: name,
+              location: target.location
+            )
+            return scope.with_override(resolved_value, &)
+          end
+
+          apply_builtin_override(name, &)
+        end
+
+        def apply_builtin_override(name, &)
+          WithModifierBuiltinOverride.new(
+            name: name,
+            value: value,
+            expression_evaluator: expression_evaluator,
+            location: target.location
+          ).apply(environment, &)
+        end
+
+        def resolved_value
+          resolved = expression_evaluator.evaluate(value)
+          resolved.is_a?(Value) ? resolved.to_ruby : resolved
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/with_modifiers/with_modifier_path_key_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../ast"
+require_relative "../value"
+
+module Ruby
+  module Rego
+    module WithModifiers
+      # Resolves reference path segments for with modifiers.
+      class WithModifierPathKeyResolver
+        # @param expression_evaluator [Evaluator::ExpressionEvaluator]
+        def initialize(expression_evaluator:)
+          @expression_evaluator = expression_evaluator
+        end
+
+        # @param segment [Object]
+        # @return [Object]
+        # :reek:FeatureEnvy
+        # :reek:TooManyStatements
+        def resolve(segment)
+          raw = segment.is_a?(AST::RefArg) ? segment.value : segment
+          key = resolved_key(raw)
+          return key if key.is_a?(UndefinedValue)
+
+          key.is_a?(Symbol) ? key.to_s : key
+        end
+
+        private
+
+        attr_reader :expression_evaluator
+
+        # :reek:FeatureEnvy
+        def resolved_key(raw)
+          resolved = expression_evaluator.evaluate(raw)
+          return resolved if resolved.is_a?(UndefinedValue)
+
+          resolved.is_a?(Value) ? resolved.to_ruby : resolved
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/with_modifiers/with_modifier_path_override.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Ruby
+  module Rego
+    module WithModifiers
+      # Applies a path-based override to a Ruby object.
+      # :reek:DataClump
+      # :reek:FeatureEnvy
+      # :reek:TooManyStatements
+      # :reek:DuplicateMethodCall
+      class WithModifierPathOverride
+        # @param base_value [Object]
+        # @param keys [Array<Object>]
+        # @param replacement [Object]
+        # @param location [Location, nil]
+        def initialize(base_value:, keys:, replacement:, location: nil)
+          @base_value = base_value
+          @keys = keys
+          @replacement = replacement
+          @location = location
+        end
+
+        # @return [Object]
+        def apply
+          apply_to(base_value, keys)
+        end
+
+        private
+
+        attr_reader :base_value, :keys, :replacement, :location
+
+        def apply_to(container, path_keys)
+          return replacement if path_keys.empty?
+
+          return apply_hash(container, path_keys) if container.is_a?(Hash)
+          return apply_array(container, path_keys) if container.is_a?(Array)
+
+          apply_missing_container(path_keys)
+        end
+
+        def apply_hash(container, path_keys)
+          key = path_keys.first
+          rest = path_keys.drop(1)
+          updated = container.dup
+          normalized_key = key.is_a?(Symbol) ? key.to_s : key
+          updated[normalized_key] = apply_to(container[normalized_key], rest)
+          updated
+        end
+
+        def apply_array(container, path_keys)
+          key = path_keys.first
+          rest = path_keys.drop(1)
+          index = array_index(key)
+          updated = container.dup
+          updated[index] = apply_to(container[index], rest)
+          updated
+        end
+
+        def array_index(key)
+          return key if key.is_a?(Integer)
+          return Integer(key, 10) if numeric_key?(key)
+
+          error = invalid_index_error(key)
+          raise error
+        rescue ArgumentError
+          error = invalid_index_error(key)
+          raise error
+        end
+
+        def apply_missing_container(path_keys)
+          key = path_keys.first
+          rest = path_keys.drop(1)
+          # @type var replacement_container: Array[Object] | Hash[Object, Object]
+          replacement_container = array_index_key?(key) ? [] : {}
+          apply_to(replacement_container, [key] + rest)
+        end
+
+        # :reek:UtilityFunction
+        def array_index_key?(key)
+          numeric_key?(key)
+        end
+
+        # :reek:UtilityFunction
+        def numeric_key?(key)
+          return true if key.is_a?(Integer)
+
+          key.is_a?(String) && key.match?(/\A-?\d+\z/)
+        end
+
+        def invalid_index_error(key)
+          message = "Invalid array index for with modifier: #{key.inspect}"
+          EvaluationError.new(message, rule: nil, location: location)
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/with_modifiers/with_modifier_root_scope.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Ruby
+  module Rego
+    module WithModifiers
+      # Encapsulates input/data root access for with modifiers.
+      class WithModifierRootScope
+        ROOT_NAMES = %w[input data].freeze
+
+        # @param environment [Environment]
+        # @param name [String]
+        # @param location [Location, nil]
+        def initialize(environment:, name:, location: nil)
+          @environment = environment
+          @name = name
+          @location = location
+          validate_name
+        end
+
+        # @return [Object]
+        def base_value
+          input_scope? ? environment.input.to_ruby : environment.data.to_ruby
+        end
+
+        # @param overridden [Object]
+        # @yieldparam environment [Environment]
+        # @return [Object]
+        def with_override(overridden, &)
+          if input_scope?
+            environment.with_overrides(input: overridden, &)
+          else
+            environment.with_overrides(data: overridden, &)
+          end
+        end
+
+        private
+
+        attr_reader :environment, :name, :location
+
+        def input_scope?
+          name == "input"
+        end
+
+        def validate_name
+          return if ROOT_NAMES.include?(name)
+
+          raise EvaluationError.new(
+            "With modifier expects input or data reference",
+            rule: nil,
+            location: location
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "rego/version"
+require_relative "rego/location"
+require_relative "rego/errors"
+require_relative "rego/error_handling"
+require_relative "rego/token"
+require_relative "rego/lexer"
+require_relative "rego/ast"
+require_relative "rego/call_name"
+require_relative "rego/parser"
+require_relative "rego/value"
+require_relative "rego/builtins/base"
+require_relative "rego/builtins/registry"
+require_relative "rego/builtins/types"
+require_relative "rego/builtins/aggregates"
+require_relative "rego/builtins/strings"
+require_relative "rego/builtins/collections"
+require_relative "rego/builtins/comparisons"
+require_relative "rego/memoization"
+require_relative "rego/environment"
+require_relative "rego/environment_pool"
+require_relative "rego/compiled_module"
+require_relative "rego/compiler"
+require_relative "rego/with_modifiers/with_modifier"
+require_relative "rego/unifier"
+require_relative "rego/result"
+require_relative "rego/evaluator"
+require_relative "rego/policy"
+
+module Ruby
+  # Top-level namespace for the Ruby Rego gem.
+  module Rego
+    class << self
+      # Parse Rego source into an AST module.
+      #
+      # @param source [String] Rego source code
+      # @return [AST::Module] parsed AST module
+      def parse(source)
+        ErrorHandling.wrap("parsing") do
+          tokens = Lexer.new(source).tokenize
+          Parser.new(tokens).parse
+        end
+      end
+
+      # Compile Rego source into an immutable compiled module.
+      #
+      # @param source [String] Rego source code
+      # @return [CompiledModule] compiled and indexed module
+      def compile(source)
+        ErrorHandling.wrap("compilation") do
+          Compiler.new.compile(parse(source))
+        end
+      end
+
+      # Evaluate Rego source against input and data.
+      #
+      # @param source [String] Rego source code
+      # @param input [Object] input document
+      # @param data [Object] data document
+      # @param query [Object, nil] optional query path
+      # @return [Result] evaluation result
+      # :reek:LongParameterList
+      def evaluate(source, input: {}, data: {}, query: nil)
+        compiled_module = compile(source)
+        ErrorHandling.wrap("evaluation") do
+          Evaluator.new(compiled_module, input: input, data: data).evaluate(query)
+        end
+      end
+    end
+  end
+end

data/sig/objspace.rbs

@@ -0,0 +1,4 @@
+module ObjectSpace
+  def self.memsize_of_all: () -> Integer
+  def self.count_objects: () -> Hash[Symbol, Integer]
+end

data/sig/psych.rbs

@@ -0,0 +1,7 @@
+module Psych
+  class BadAlias < StandardError
+  end
+
+  class SyntaxError < StandardError
+  end
+end