ruby-rego 0.1.0

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# rubocop:disable Naming/PredicatePrefix
+
+require_relative "base"
+require_relative "registry"
+
+module Ruby
+  module Rego
+    module Builtins
+      # Built-in type predicates.
+      module Types
+        TYPE_PREDICATES = {
+          "is_string" => :is_string,
+          "is_number" => :is_number,
+          "is_boolean" => :is_boolean,
+          "is_array" => :is_array,
+          "is_object" => :is_object,
+          "is_set" => :is_set,
+          "is_null" => :is_null
+        }.freeze
+
+        # @return [Ruby::Rego::Builtins::BuiltinRegistry]
+        def self.register!
+          registry = BuiltinRegistry.instance
+
+          TYPE_PREDICATES.each do |name, handler|
+            register_predicate(registry, name, handler)
+          end
+
+          registry
+        end
+
+        def self.register_predicate(registry, name, handler)
+          return if registry.registered?(name)
+
+          registry.register(name, 1) { |value| public_send(handler, value) }
+        end
+        private_class_method :register_predicate
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_string(value)
+          BooleanValue.new(value.is_a?(StringValue))
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_number(value)
+          BooleanValue.new(value.is_a?(NumberValue))
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_boolean(value)
+          BooleanValue.new(value.is_a?(BooleanValue))
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_array(value)
+          BooleanValue.new(value.is_a?(ArrayValue))
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_object(value)
+          BooleanValue.new(value.is_a?(ObjectValue))
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_set(value)
+          BooleanValue.new(value.is_a?(SetValue))
+        end
+
+        # @param value [Ruby::Rego::Value]
+        # @return [Ruby::Rego::BooleanValue]
+        def self.is_null(value)
+          BooleanValue.new(value.is_a?(NullValue))
+        end
+      end
+    end
+  end
+end
+
+Ruby::Rego::Builtins::Types.register!
+
+# rubocop:enable Naming/PredicatePrefix

data/lib/ruby/rego/call_name.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "ast"
+
+module Ruby
+  module Rego
+    # Shared call name resolution helpers.
+    # NOTE: Internal helper module, not a stable public API.
+    module CallName
+      module_function
+
+      def call_name(node)
+        return node.name if node.is_a?(AST::Variable)
+        return node.to_s if node.is_a?(String) || node.is_a?(Symbol)
+        return reference_call_name(node) if node.is_a?(AST::Reference)
+
+        nil
+      end
+
+      def reference_call_name(reference)
+        base_name = reference_base_name(reference)
+        return nil unless base_name
+
+        segments = reference_call_segments(reference.path)
+        return nil unless segments
+
+        ([base_name] + segments).join(".")
+      end
+
+      def reference_base_name(reference)
+        base = reference.base
+        base.is_a?(AST::Variable) ? base.name : nil
+      end
+
+      def reference_call_segments(path)
+        segments = path.map { |segment| dot_ref_segment_value(segment) }
+        return nil if segments.any?(&:nil?)
+
+        segments.compact
+      end
+
+      def dot_ref_segment_value(segment)
+        value = segment.value
+        case segment
+        when AST::DotRefArg
+          return value.to_s if value.is_a?(String) || value.is_a?(Symbol)
+        when AST::BracketRefArg
+          return value.value.to_s if value.is_a?(AST::StringLiteral)
+        end
+
+        nil
+      end
+    end
+  end
+end