ruby-rego 0.1.0

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../errors"
+require_relative "../../value"
+
+module Ruby
+  module Rego
+    module Builtins
+      module Collections
+        # Object-focused collection helpers.
+        module ObjectOps
+          # @param object [Ruby::Rego::Value]
+          # @param key [Ruby::Rego::Value]
+          # @param default [Ruby::Rego::Value]
+          # @return [Ruby::Rego::Value]
+          def self.object_get(object, key, default)
+            obj = object_value(object, name: "object.get object")
+            key_value = normalize_object_key(Base.to_ruby(key))
+            value = obj.fetch_reference(key_value)
+            value.is_a?(UndefinedValue) ? default : value
+          end
+
+          # @param object [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ArrayValue]
+          def self.object_keys(object)
+            obj = object_value(object, name: "object.keys")
+            ArrayValue.new(obj.value.keys)
+          end
+
+          # @param object [Ruby::Rego::Value]
+          # @param keys [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ObjectValue]
+          def self.object_remove(object, keys)
+            obj = object_value(object, name: "object.remove object")
+            remove_keys = key_collection(keys, name: "object.remove keys")
+            filtered = obj.value.reject { |key, _value| remove_keys.include?(normalize_object_key(key)) }
+            ObjectValue.new(filtered)
+          end
+
+          # @param left [Ruby::Rego::Value]
+          # @param right [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ObjectValue]
+          def self.union_objects(left, right)
+            left_obj = object_value(left, name: "union left").value
+            right_obj = object_value(right, name: "union right").value
+            ObjectValue.new(merge_objects(left_obj, right_obj))
+          end
+
+          def self.object_value(value, name:)
+            object = value # @type var object: ObjectValue
+            Base.assert_type(object, expected: ObjectValue, context: name)
+            object
+          end
+          private_class_method :object_value
+
+          def self.normalize_object_key(key)
+            key.is_a?(Symbol) ? key.to_s : key
+          end
+          private_class_method :normalize_object_key
+
+          def self.key_collection(keys, name:)
+            values = key_values(keys, name: name)
+            Set.new(values.map { |key| normalize_object_key(Base.to_ruby(key)) })
+          end
+          private_class_method :key_collection
+
+          def self.key_values(keys, name:)
+            return array_key_values(keys) if keys.is_a?(ArrayValue)
+            return values_from_set(keys) if keys.is_a?(SetValue)
+
+            Base.assert_type(keys, expected: [ArrayValue, SetValue], context: name)
+            []
+          end
+          private_class_method :key_values
+
+          def self.array_key_values(keys)
+            keys.value
+          end
+          private_class_method :array_key_values
+
+          def self.values_from_set(keys)
+            keys.value.to_a
+          end
+          private_class_method :values_from_set
+
+          def self.merge_objects(left_obj, right_obj)
+            conflict = conflicting_key(left_obj, right_obj)
+            raise_object_conflict(conflict, left_obj, right_obj) if conflict
+
+            left_obj.merge(right_obj)
+          end
+          private_class_method :merge_objects
+
+          def self.conflicting_key(left_obj, right_obj)
+            left_obj.each_key do |key|
+              next unless right_obj.key?(key)
+              next if left_obj[key] == right_obj[key]
+
+              return key
+            end
+            nil
+          end
+          private_class_method :conflicting_key
+
+          def self.raise_object_conflict(key, left_obj, right_obj)
+            raise Ruby::Rego::BuiltinArgumentError.new(
+              "Conflicting object keys",
+              expected: "matching values for key #{key.inspect}",
+              actual: [left_obj[key].to_ruby, right_obj[key].to_ruby],
+              context: "union",
+              location: nil
+            )
+          end
+          private_class_method :raise_object_conflict
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../errors"
+require_relative "../../value"
+
+module Ruby
+  module Rego
+    module Builtins
+      module Collections
+        # Set-focused collection helpers.
+        module SetOps
+          # @param left [Ruby::Rego::Value]
+          # @param right [Ruby::Rego::Value]
+          # @return [Ruby::Rego::SetValue]
+          def self.intersection(left, right)
+            set_operation(left, right, name: "intersection") { |left_set, right_set| left_set & right_set }
+          end
+
+          # @param left [Ruby::Rego::Value]
+          # @param right [Ruby::Rego::Value]
+          # @return [Ruby::Rego::SetValue]
+          def self.set_diff(left, right)
+            set_operation(left, right, name: "set_diff") { |left_set, right_set| left_set - right_set }
+          end
+
+          # @param left [Ruby::Rego::Value]
+          # @param right [Ruby::Rego::Value]
+          # @return [Ruby::Rego::SetValue]
+          def self.union_sets(left, right)
+            set_operation(left, right, name: "union") { |left_set, right_set| left_set | right_set }
+          end
+
+          def self.set_operation(left, right, name:)
+            left_set = set_contents(left, name: "#{name} left")
+            right_set = set_contents(right, name: "#{name} right")
+            SetValue.new(yield(left_set, right_set))
+          end
+          private_class_method :set_operation
+
+          def self.set_contents(value, name:)
+            set_contents = value # @type var set_contents: SetValue
+            Base.assert_type(set_contents, expected: SetValue, context: name)
+            set_contents.value
+          end
+          private_class_method :set_contents
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+require_relative "registry_helpers"
+require_relative "../errors"
+require_relative "../value"
+require_relative "collections/array_ops"
+require_relative "collections/object_ops"
+require_relative "collections/set_ops"
+
+module Ruby
+  module Rego
+    module Builtins
+      # Built-in collection helpers.
+      module Collections
+        extend RegistryHelpers
+
+        MISSING_SET_ARGUMENT = Object.new.freeze
+
+        COLLECTION_FUNCTIONS = {
+          "set" => { arity: [0, 1], handler: :set },
+          "sort" => { arity: 1, handler: :sort },
+          "array.concat" => { arity: 2, handler: :array_concat },
+          "array.slice" => { arity: 3, handler: :array_slice },
+          "object.get" => { arity: 3, handler: :object_get },
+          "object.keys" => { arity: 1, handler: :object_keys },
+          "object.remove" => { arity: 2, handler: :object_remove },
+          "union" => { arity: 2, handler: :union },
+          "intersection" => { arity: 2, handler: :intersection },
+          "set_diff" => { arity: 2, handler: :set_diff }
+        }.freeze
+
+        # @return [Ruby::Rego::Builtins::BuiltinRegistry]
+        def self.register!
+          registry = BuiltinRegistry.instance
+
+          register_configured_functions(registry, COLLECTION_FUNCTIONS)
+
+          registry
+        end
+
+        private_class_method :register_configured_functions, :register_configured_function
+
+        # @param array [Ruby::Rego::Value]
+        # @return [Ruby::Rego::ArrayValue]
+        def self.sort(array)
+          ArrayOps.sort(array)
+        end
+
+        # @param value [Ruby::Rego::Value, nil]
+        # @return [Ruby::Rego::SetValue]
+        def self.set(value = MISSING_SET_ARGUMENT)
+          return SetValue.new([]) if value.equal?(MISSING_SET_ARGUMENT)
+
+          Base.assert_type(value, expected: [ArrayValue, SetValue], context: "set")
+          return value if value.is_a?(SetValue)
+
+          SetValue.new(value.value)
+        end
+
+        # @param left [Ruby::Rego::Value]
+        # @param right [Ruby::Rego::Value]
+        # @return [Ruby::Rego::ArrayValue]
+        def self.array_concat(left, right)
+          ArrayOps.array_concat(left, right)
+        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)
+          ArrayOps.array_slice(array, start, stop)
+        end
+
+        # @param object [Ruby::Rego::Value]
+        # @param key [Ruby::Rego::Value]
+        # @param default [Ruby::Rego::Value]
+        # @return [Ruby::Rego::Value]
+        def self.object_get(object, key, default)
+          ObjectOps.object_get(object, key, default)
+        end
+
+        # @param object [Ruby::Rego::Value]
+        # @return [Ruby::Rego::ArrayValue]
+        def self.object_keys(object)
+          ObjectOps.object_keys(object)
+        end
+
+        # @param object [Ruby::Rego::Value]
+        # @param keys [Ruby::Rego::Value]
+        # @return [Ruby::Rego::ObjectValue]
+        def self.object_remove(object, keys)
+          ObjectOps.object_remove(object, keys)
+        end
+
+        # @param left [Ruby::Rego::Value]
+        # @param right [Ruby::Rego::Value]
+        # @return [Ruby::Rego::Value]
+        def self.union(left, right)
+          return SetOps.union_sets(left, right) if left.is_a?(SetValue) && right.is_a?(SetValue)
+          return ObjectOps.union_objects(left, right) if left.is_a?(ObjectValue) && right.is_a?(ObjectValue)
+
+          raise_union_type_error(left, right)
+        end
+
+        # @param left [Ruby::Rego::Value]
+        # @param right [Ruby::Rego::Value]
+        # @return [Ruby::Rego::SetValue]
+        def self.intersection(left, right)
+          SetOps.intersection(left, right)
+        end
+
+        # @param left [Ruby::Rego::Value]
+        # @param right [Ruby::Rego::Value]
+        # @return [Ruby::Rego::SetValue]
+        def self.set_diff(left, right)
+          SetOps.set_diff(left, right)
+        end
+
+        def self.raise_union_type_error(left, right)
+          raise Ruby::Rego::BuiltinArgumentError.new(
+            "Type mismatch",
+            expected: "both sets or both objects",
+            actual: "#{left.class.name} and #{right.class.name}",
+            context: "union",
+            location: nil
+          )
+        end
+        private_class_method :raise_union_type_error
+      end
+    end
+  end
+end
+
+Ruby::Rego::Builtins::Collections.register!

data/lib/ruby/rego/builtins/comparisons/casts.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../errors"
+require_relative "../../value"
+
+module Ruby
+  module Rego
+    module Builtins
+      module Comparisons
+        # Casting and conversion helpers.
+        module Casts
+          # @param value [Ruby::Rego::Value]
+          # @return [Ruby::Rego::NumberValue]
+          def self.to_number(value)
+            raw = value.value
+            return NumberValue.new(raw) if value.is_a?(NumberValue)
+            return NumberValue.new(number_from_string(raw)) if value.is_a?(StringValue)
+
+            raise_type_mismatch("to_number", "number or string", value.class.name)
+          end
+
+          # @param value [Ruby::Rego::Value]
+          # @return [Ruby::Rego::StringValue]
+          def self.cast_string(value)
+            Base.assert_type(
+              value,
+              expected: [StringValue, NumberValue, BooleanValue, NullValue],
+              context: "cast_string"
+            )
+
+            return value if value.is_a?(StringValue)
+            return StringValue.new("null") if value.is_a?(NullValue)
+
+            StringValue.new(Base.to_ruby(value).to_s)
+          end
+
+          # @param value [Ruby::Rego::Value]
+          # @return [Ruby::Rego::BooleanValue]
+          def self.cast_boolean(value)
+            return value if value.is_a?(BooleanValue)
+
+            raw = value.value
+            return boolean_from_string(raw) if value.is_a?(StringValue)
+            return boolean_from_number(raw) if value.is_a?(NumberValue)
+
+            raise_type_mismatch("cast_boolean", "boolean, string, or number", value.class.name)
+          end
+
+          # @param value [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ArrayValue]
+          def self.cast_array(value)
+            return value if value.is_a?(ArrayValue)
+
+            Base.assert_type(value, expected: [ArrayValue, SetValue], context: "cast_array")
+            ArrayValue.new(value.value.to_a)
+          end
+
+          # @param value [Ruby::Rego::Value]
+          # @return [Ruby::Rego::SetValue]
+          def self.cast_set(value)
+            return value if value.is_a?(SetValue)
+
+            Base.assert_type(value, expected: [SetValue, ArrayValue], context: "cast_set")
+            SetValue.new(value.value)
+          end
+
+          # @param value [Ruby::Rego::Value]
+          # @return [Ruby::Rego::ObjectValue]
+          def self.cast_object(value)
+            object = value # @type var object: ObjectValue
+            Base.assert_type(object, expected: ObjectValue, context: "cast_object")
+            object
+          end
+
+          def self.number_from_string(text)
+            Integer(text, 10)
+          rescue ArgumentError
+            float = Float(text, exception: false)
+            return float if float&.finite?
+
+            raise_number_error(text)
+          end
+          private_class_method :number_from_string
+
+          def self.raise_number_error(text)
+            raise Ruby::Rego::BuiltinArgumentError.new(
+              "Invalid number string",
+              expected: "numeric string",
+              actual: text,
+              context: "to_number",
+              location: nil
+            )
+          end
+          private_class_method :raise_number_error
+
+          def self.boolean_from_string(text)
+            normalized = text.strip.downcase
+            return BooleanValue.new(true) if normalized == "true"
+            return BooleanValue.new(false) if normalized == "false"
+
+            raise_cast_error("Expected boolean string", "cast_boolean", text)
+          end
+          private_class_method :boolean_from_string
+
+          def self.boolean_from_number(number)
+            return BooleanValue.new(false) if number.zero?
+            return BooleanValue.new(true) if number == 1
+
+            raise_cast_error("Expected 0 or 1 for boolean cast", "cast_boolean", number)
+          end
+          private_class_method :boolean_from_number
+
+          def self.raise_cast_error(message, context, actual)
+            raise Ruby::Rego::BuiltinArgumentError.new(
+              message,
+              expected: "castable value",
+              actual: actual,
+              context: context,
+              location: nil
+            )
+          end
+          private_class_method :raise_cast_error
+
+          def self.raise_type_mismatch(context, expected, actual)
+            raise Ruby::Rego::BuiltinArgumentError.new(
+              "Type mismatch",
+              expected: expected,
+              actual: actual,
+              context: context,
+              location: nil
+            )
+          end
+          private_class_method :raise_type_mismatch
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "registry"
+require_relative "registry_helpers"
+require_relative "../value"
+require_relative "comparisons/casts"
+
+module Ruby
+  module Rego
+    module Builtins
+      # Built-in comparison and casting helpers.
+      module Comparisons
+        extend RegistryHelpers
+
+        COMPARISON_FUNCTIONS = {
+          "equal" => { arity: 2, handler: :equal },
+          "to_number" => { arity: 1, handler: :to_number },
+          "cast_string" => { arity: 1, handler: :cast_string },
+          "cast_boolean" => { arity: 1, handler: :cast_boolean },
+          "cast_array" => { arity: 1, handler: :cast_array },
+          "cast_set" => { arity: 1, handler: :cast_set },
+          "cast_object" => { arity: 1, handler: :cast_object }
+        }.freeze
+
+        # @return [Ruby::Rego::Builtins::BuiltinRegistry]
+        def self.register!
+          registry = BuiltinRegistry.instance
+
+          register_configured_functions(registry, COMPARISON_FUNCTIONS)
+
+          registry
+        end
+
+        private_class_method :register_configured_functions, :register_configured_function
+
+        # @param left [Ruby::Rego::Value]
+        # @param right [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.equal(left, right)
+          BooleanValue.new(left == right)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::NumberValue]
+        def self.to_number(value)
+          Casts.to_number(value)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::StringValue]
+        def self.cast_string(value)
+          Casts.cast_string(value)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.cast_boolean(value)
+          Casts.cast_boolean(value)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::ArrayValue]
+        def self.cast_array(value)
+          Casts.cast_array(value)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::SetValue]
+        def self.cast_set(value)
+          Casts.cast_set(value)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::ObjectValue]
+        def self.cast_object(value)
+          Casts.cast_object(value)
+        end
+      end
+    end
+  end
+end
+
+Ruby::Rego::Builtins::Comparisons.register!

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../errors"
+require_relative "../value"
+
+module Ruby
+  module Rego
+    module Builtins
+      # Shared numeric coercion helpers for builtins.
+      module NumericHelpers
+        # @param value [Ruby::Rego::Value]
+        # @param context [String]
+        # @return [Integer]
+        def self.integer_value(value, context:)
+          Base.assert_type(value, expected: NumberValue, context: context)
+          numeric = value.value
+          return numeric if numeric.is_a?(Integer)
+          return numeric.to_i if numeric.is_a?(Float) && numeric.finite? && numeric.modulo(1).zero?
+
+          raise_integer_error(numeric, context)
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @param context [String]
+        # @return [Integer]
+        def self.non_negative_integer(value, context:)
+          integer = integer_value(value, context: context)
+          return integer if integer >= 0
+
+          raise Ruby::Rego::BuiltinArgumentError.new(
+            "Expected non-negative integer",
+            expected: "non-negative integer",
+            actual: integer,
+            context: context,
+            location: nil
+          )
+        end
+
+        # @param numeric [Numeric]
+        # @param context [String]
+        # @return [void]
+        def self.raise_integer_error(numeric, context)
+          raise Ruby::Rego::BuiltinArgumentError.new(
+            "Expected integer",
+            expected: "integer",
+            actual: numeric,
+            context: context,
+            location: nil
+          )
+        end
+        private_class_method :raise_integer_error
+      end
+    end
+  end
+end