ruby-rego 0.1.0

data/lib/ruby/rego/evaluator/assignment_support.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    class Evaluator
+      # Shared helpers for assignment/unification logic.
+      module AssignmentSupport
+        private
+
+        # :reek:TooManyStatements
+        def evaluate_assignment(node)
+          pattern = node.left
+          value = evaluate(node.right)
+          binding_sets = unifier.unify(pattern, value, environment)
+          return UndefinedValue.new unless binding_sets.size == 1
+
+          apply_bindings(binding_sets.first)
+          value
+        end
+
+        # :reek:TooManyStatements
+        def evaluate_unification(node)
+          binding_sets, resolved_value = unification_result(node, environment)
+          return UndefinedValue.new unless binding_sets.size == 1
+
+          apply_bindings(binding_sets.first)
+          resolved_value
+        end
+
+        # :reek:TooManyStatements
+        def unification_binding_sets(node, env)
+          binding_sets, = unification_result(node, env)
+          binding_sets
+        end
+
+        # :reek:TooManyStatements
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def unification_result(node, env)
+          left_node = node.left
+          right_node = node.right
+          right_value = evaluate(right_node)
+          right_undefined = right_value.is_a?(UndefinedValue)
+          if right_undefined && left_node.is_a?(AST::Reference) && right_node.is_a?(AST::Variable)
+            bindings = bind_reference_variable(right_node, reference_bindings_for(left_node, env))
+            return [bindings, UndefinedValue.new]
+          end
+          # @type var binding_sets: Array[Hash[String, Value]]
+          binding_sets = []
+          binding_sets = unifier.unify(left_node, right_value, env) unless right_undefined
+          return [binding_sets, right_value] unless binding_sets.empty?
+
+          left_value = evaluate(left_node)
+          return [binding_sets, left_value] if left_value.is_a?(UndefinedValue)
+
+          [unifier.unify(right_node, left_value, env), left_value]
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        # :reek:TooManyStatements
+        # :reek:UtilityFunction
+        def reference_bindings_for(reference, env)
+          base_value = reference_base_override(reference)
+          unifier.reference_bindings(
+            reference,
+            env,
+            {},
+            base_value: base_value,
+            variable_resolver: method(:resolve_reference_variable_key)
+          )
+        end
+
+        def reference_base_override(reference)
+          name = reference_base_name(reference)
+          return nil unless name
+
+          resolve_reference_base(name)
+        end
+
+        def reference_base_name(reference)
+          case reference.base
+          in AST::Variable[name:]
+            return nil unless unresolved_reference_base?(name)
+
+            name
+          else
+            nil
+          end
+        end
+
+        def unresolved_reference_base?(name)
+          !environment.local_bound?(name) && environment.lookup(name).is_a?(UndefinedValue)
+        end
+
+        def resolve_reference_base(name)
+          reference_resolver.resolve_import_variable(name) ||
+            reference_resolver.resolve_rule_variable(name)
+        end
+
+        # :reek:TooManyStatements
+        # :reek:UtilityFunction
+        def bind_reference_variable(variable, reference_bindings)
+          reference_bindings.filter_map do |(bindings, value)|
+            next if value.is_a?(UndefinedValue)
+
+            name = variable.name
+            next bindings if name == "_"
+
+            existing = bindings[name]
+            next if existing && existing != value
+
+            additions = {} # @type var additions: Hash[String, Value]
+            additions[name] = value
+            bindings.merge(additions)
+          end
+        end
+
+        def apply_bindings(bindings)
+          bindings.each do |name, binding_value|
+            environment.bind(name, binding_value)
+          end
+          bindings
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/evaluator/binding_helpers.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    class Evaluator
+      # Shared helpers for collection binding iteration.
+      # :reek:DataClump
+      module BindingHelpers
+        private
+
+        # :reek:NestedIterators
+        # :reek:TooManyStatements
+        def each_array_binding(variables, collection_value)
+          Enumerator.new do |yielder|
+            values = collection_value.to_ruby
+            case variables.length
+            when 1 then values.each { |value| yielder << bindings_for(variables[0], value) }
+            when 2 then values.each_with_index { |value, index| yielder << bindings_for_pair(variables, index, value) }
+            end
+          end
+        end
+
+        # :reek:NestedIterators
+        def each_set_binding(variables, collection_value)
+          Enumerator.new do |yielder|
+            collection_value.to_ruby.each do |value|
+              yielder << bindings_for(variables[0], value)
+            end
+          end
+        end
+
+        # :reek:NestedIterators
+        # :reek:TooManyStatements
+        def each_object_binding(variables, collection_value)
+          Enumerator.new do |yielder|
+            pairs = collection_value.to_ruby
+            case variables.length
+            when 1 then pairs.each_key { |key| yielder << bindings_for(variables[0], key) }
+            when 2 then pairs.each { |key, value| yielder << bindings_for_pair(variables, key, value) }
+            end
+          end
+        end
+
+        def bindings_for_pair(variables, first_value, second_value)
+          bindings = bindings_for(variables[0], first_value)
+          bindings.merge!(bindings_for(variables[1], second_value))
+          bindings
+        end
+
+        # :reek:UtilityFunction
+        def bindings_for(variable, value)
+          name = variable.name
+          return {} if name == "_"
+
+          { name => Value.from_ruby(value) }
+        end
+      end
+    end
+  end
+end

data/lib/ruby/rego/evaluator/comprehension_evaluator.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    class Evaluator
+      # Evaluates comprehensions in isolated scopes.
+      # :reek:TooManyMethods
+      # rubocop:disable Metrics/ClassLength
+      class ComprehensionEvaluator
+        # Tracks object keys for conflict detection.
+        class ObjectAccumulator
+          def initialize
+            @key_sources = {} # @type var @key_sources: Hash[Object, Object]
+          end
+
+          # :reek:TooManyStatements
+          def add(values, key, value)
+            normalized_key = key.is_a?(Symbol) ? key.to_s : key
+            if key_sources.key?(normalized_key)
+              existing = key_sources[normalized_key]
+              raise ObjectKeyConflictError, "Conflicting object keys: #{existing.inspect} and #{key.inspect}"
+            end
+            key_sources[normalized_key] = key
+            values[normalized_key] = value
+          end
+
+          private
+
+          attr_reader :key_sources
+        end
+
+        private_constant :ObjectAccumulator
+
+        # Bundles object comprehension accumulation state.
+        ObjectPairContext = Struct.new(:result_values, :accumulator)
+        private_constant :ObjectPairContext
+
+        # @param expression_evaluator [ExpressionEvaluator]
+        # @param environment [Environment]
+        def initialize(expression_evaluator:, environment:)
+          @expression_evaluator = expression_evaluator
+          @environment = environment
+          @query_evaluator = nil
+        end
+
+        # @param query_evaluator [RuleEvaluator]
+        # @return [void]
+        def attach_query_evaluator(query_evaluator)
+          @query_evaluator = query_evaluator
+          nil
+        end
+
+        # @param node [AST::ArrayComprehension]
+        # @return [Value]
+        def eval_array(node)
+          ArrayValue.new(collect_values(node))
+        end
+
+        # @param node [AST::ObjectComprehension]
+        # @return [Value]
+        def eval_object(node)
+          ObjectValue.new(object_pairs(node))
+        end
+
+        # @param node [AST::SetComprehension]
+        # @return [Value]
+        def eval_set(node)
+          SetValue.new(collect_values(node))
+        end
+
+        private
+
+        attr_reader :expression_evaluator, :environment, :query_evaluator
+
+        def object_pairs(node)
+          values = {} # @type var values: Hash[Object, Value]
+          context = ObjectPairContext.new(values, ObjectAccumulator.new)
+          each_comprehension_binding(node.body) do |bindings|
+            apply_object_binding(context, node.term, bindings)
+          end
+          values
+        end
+
+        def apply_object_binding(context, term, bindings)
+          environment.with_bindings(bindings) do
+            pair = resolve_pair(term)
+            return unless pair
+
+            key, value = pair
+            context.accumulator.add(context.result_values, key, value)
+          end
+        end
+
+        def resolve_pair(term)
+          key = evaluate_defined_key(term[0])
+          return nil if key.is_a?(Value) && key.undefined?
+
+          value = evaluate_defined_value(term[1])
+          return nil unless value
+
+          [key, value]
+        end
+
+        def each_comprehension_binding(body, &)
+          with_comprehension_scope(body) { comprehension_solutions(body).each(&) }
+        end
+
+        def collect_values(node)
+          values = [] # @type var values: Array[Value]
+          each_comprehension_binding(node.body) do |bindings|
+            append_value(values, node.term, bindings)
+          end
+          values
+        end
+
+        def append_value(values, term, bindings)
+          environment.with_bindings(bindings) do
+            value = evaluate_defined_value(term)
+            values << value if value
+          end
+        end
+
+        # :reek:FeatureEnvy
+        def evaluate_defined_key(node)
+          value = expression_evaluator.evaluate(node)
+          return UndefinedValue.new if value.is_a?(Value) && value.undefined?
+
+          value.object_key
+        end
+
+        # :reek:FeatureEnvy
+        def evaluate_defined_value(node)
+          value = expression_evaluator.evaluate(node)
+          return nil if value.is_a?(Value) && value.undefined?
+
+          value
+        end
+
+        def comprehension_solutions(body)
+          return query_evaluator.query_solutions(body, environment) if query_evaluator
+
+          raise EvaluationError.new("Query evaluator not configured", rule: nil, location: nil)
+        end
+
+        def with_comprehension_scope(body)
+          environment.push_scope
+          shadow_comprehension_locals(body)
+          yield
+        ensure
+          environment.pop_scope
+        end
+
+        def shadow_comprehension_locals(body)
+          details = BoundVariableCollector.new.collect_details(body)
+          explicit = details[:explicit]
+          shadow_explicit_locals(explicit)
+          shadow_unification_locals(details[:unification], explicit)
+        end
+
+        def shadow_explicit_locals(names)
+          names.each { |name| bind_undefined(name) }
+        end
+
+        def shadow_unification_locals(names, explicit_names)
+          names.each do |name|
+            next if explicit_names.include?(name)
+            next unless environment.lookup(name).is_a?(UndefinedValue)
+
+            bind_undefined(name)
+          end
+        end
+
+        def bind_undefined(name)
+          return if Environment::RESERVED_NAMES.include?(name) || name == "_"
+
+          environment.bind(name, UndefinedValue.new)
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/ruby/rego/evaluator/expression_dispatch.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ruby
+  module Rego
+    class Evaluator
+      # Dispatches expression evaluation for primitive and AST nodes.
+      class ExpressionDispatch
+        # @param primitive_types [Array<Class>]
+        # @param node_evaluators [Array<Array<Class, Proc>>]
+        def initialize(primitive_types:, node_evaluators:)
+          @primitive_types = primitive_types
+          @node_evaluators = node_evaluators
+          @handler_cache = {} # @type var handler_cache: Hash[Class, Proc?]
+        end
+
+        # @param node [Object]
+        # @return [Value, nil]
+        def primitive_value(node)
+          return Value.from_ruby(node) if primitive_types.any? { |klass| node.is_a?(klass) }
+
+          nil
+        end
+
+        # @param node [Object]
+        # @param evaluator [ExpressionEvaluator]
+        # @return [Value, nil]
+        def dispatch_node(node, evaluator)
+          handler = handler_for(node)
+          handler&.call(node, evaluator)
+        end
+
+        private
+
+        attr_reader :primitive_types, :node_evaluators, :handler_cache
+
+        def handler_for(node)
+          node_class = node.class
+          return handler_cache[node_class] if handler_cache.key?(node_class)
+
+          handler_cache[node_class] = node_evaluators.find { |klass, _| node.is_a?(klass) }&.last
+        end
+      end
+    end
+  end
+end