easy_talk 3.2.0 → 3.3.1

data/lib/easy_talk/type_introspection.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require 'bigdecimal'
 
@@ -31,6 +32,8 @@ module EasyTalk
     }.freeze
 
     class << self
+      extend T::Sig
+
       # Check if type represents a boolean (T::Boolean or TrueClass/FalseClass).
       #
       # @param type [Object] The type to check
@@ -41,6 +44,7 @@ module EasyTalk
       #   boolean_type?(TrueClass)   # => true
       #   boolean_type?(FalseClass)  # => true
       #   boolean_type?(String)      # => false
+      sig { params(type: T.untyped).returns(T::Boolean) }
       def boolean_type?(type)
         return false if type.nil?
         return true if [TrueClass, FalseClass].include?(type)
@@ -58,6 +62,23 @@ module EasyTalk
         false
       end
 
+      # Check if a resolved type class represents a boolean union ([TrueClass, FalseClass]).
+      #
+      # This is useful when checking resolved type classes rather than raw Sorbet types.
+      # The internal representation of T::Boolean resolves to [TrueClass, FalseClass].
+      #
+      # @param type_class [Object] The resolved type class to check
+      # @return [Boolean] true if the type class is a boolean union array
+      #
+      # @example
+      #   boolean_union_type?([TrueClass, FalseClass]) # => true
+      #   boolean_union_type?(TrueClass)               # => false
+      #   boolean_union_type?(String)                  # => false
+      sig { params(type_class: T.untyped).returns(T::Boolean) }
+      def boolean_union_type?(type_class)
+        type_class.is_a?(Array) && type_class.sort_by(&:name) == [FalseClass, TrueClass].sort_by(&:name)
+      end
+
       # Check if type is a typed array (T::Array[...]).
       #
       # @param type [Object] The type to check
@@ -66,12 +87,30 @@ module EasyTalk
       # @example
       #   typed_array?(T::Array[String]) # => true
       #   typed_array?(Array)            # => false
+      sig { params(type: T.untyped).returns(T::Boolean) }
       def typed_array?(type)
         return false if type.nil?
 
         type.is_a?(T::Types::TypedArray)
       end
 
+      # Check if type is any array type (plain Array, T::Array[...], or T::Tuple[...]).
+      #
+      # @param type [Object] The type to check
+      # @return [Boolean] true if the type is an array type
+      #
+      # @example
+      #   array_type?(Array)                      # => true
+      #   array_type?(T::Array[String])           # => true
+      #   array_type?(T::Tuple[String, Integer])  # => true
+      #   array_type?(String)                     # => false
+      sig { params(type: T.untyped).returns(T::Boolean) }
+      def array_type?(type)
+        return false if type.nil?
+
+        type == Array || type.is_a?(T::Types::TypedArray) || type.is_a?(EasyTalk::Types::Tuple)
+      end
+
       # Check if type is nilable (T.nilable(...)).
       #
       # @param type [Object] The type to check
@@ -80,6 +119,7 @@ module EasyTalk
       # @example
       #   nilable_type?(T.nilable(String)) # => true
       #   nilable_type?(String)            # => false
+      sig { params(type: T.untyped).returns(T::Boolean) }
       def nilable_type?(type)
         return false if type.nil?
 
@@ -90,6 +130,7 @@ module EasyTalk
       #
       # @param type [Object] The type to check
       # @return [Boolean] true if the type is a primitive
+      sig { params(type: T.untyped).returns(T::Boolean) }
       def primitive_type?(type)
         return false if type.nil?
 
@@ -111,6 +152,7 @@ module EasyTalk
       #   json_schema_type(Float)      # => 'number'
       #   json_schema_type(BigDecimal) # => 'number'
       #   json_schema_type(String)     # => 'string'
+      sig { params(type: T.untyped).returns(String) }
       def json_schema_type(type)
         return 'object' if type.nil?
         return 'boolean' if boolean_type?(type)
@@ -133,11 +175,12 @@ module EasyTalk
       #   get_type_class(String)           # => String
       #   get_type_class(T::Boolean)       # => [TrueClass, FalseClass]
       #   get_type_class(T::Array[String]) # => Array
+      sig { params(type: T.untyped).returns(T.untyped) }
       def get_type_class(type)
         return nil if type.nil?
         return type if type.is_a?(Class)
         return type.raw_type if type.respond_to?(:raw_type)
-        return Array if typed_array?(type)
+        return Array if type.is_a?(T::Types::TypedArray) || type.is_a?(EasyTalk::Types::Tuple)
         return [TrueClass, FalseClass] if boolean_type?(type)
 
         if nilable_type?(type)
@@ -155,6 +198,7 @@ module EasyTalk
       #
       # @example
       #   extract_inner_type(T.nilable(String)) # => String
+      sig { params(type: T.untyped).returns(T.untyped) }
       def extract_inner_type(type)
         return type if type.nil?
 

data/lib/easy_talk/types/tuple.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module Types
+    # Represents a tuple type for arrays with positional type validation.
+    #
+    # A tuple is an array where each position has a specific type. This class
+    # stores the types for each position.
+    #
+    # @example Basic tuple
+    #   T::Tuple[String, Integer]  # First item must be String, second must be Integer
+    #
+    # @example With additional_items constraint
+    #   property :flags, T::Tuple[T::Boolean, T::Boolean], additional_items: false
+    #
+    class Tuple
+      extend T::Sig
+
+      # @return [Array<Object>] The types for each position in the tuple
+      sig { returns(T::Array[T.untyped]) }
+      attr_reader :types
+
+      # Creates a new Tuple instance with the given positional types.
+      #
+      # @param types [Array] The types for each position in the tuple
+      # @raise [ArgumentError] if types is empty or contains nil values
+      sig { params(types: T.untyped).void }
+      def initialize(*types)
+        raise ArgumentError, 'Tuple requires at least one type' if types.empty?
+        raise ArgumentError, 'Tuple types cannot be nil' if types.any?(&:nil?)
+
+        @types = types.freeze
+      end
+
+      # Returns a string representation of the tuple type.
+      #
+      # @return [String] A human-readable representation
+      sig { returns(String) }
+      def to_s
+        type_names = @types.map { |t| (t.respond_to?(:name) && t.name) || t.to_s }
+        "T::Tuple[#{type_names.join(', ')}]"
+      end
+
+      # Returns the name of this type (used by Property for error messages).
+      #
+      # @return [String] The type name
+      sig { returns(String) }
+      def name
+        to_s
+      end
+    end
+  end
+end
+
+# Add T::Tuple module for bracket syntax
+module T
+  # Provides tuple type syntax: T::Tuple[Type1, Type2, ...]
+  #
+  # Creates a tuple type that validates array elements by position.
+  #
+  # @example Basic usage
+  #   property :coordinates, T::Tuple[Float, Float]
+  #   property :record, T::Tuple[String, Integer, T::Boolean]
+  #
+  # @example With additional_items constraint
+  #   property :flags, T::Tuple[T::Boolean, T::Boolean], additional_items: false
+  #
+  module Tuple
+    # Creates a new Tuple type with the given positional types.
+    #
+    # @param types [Array] The types for each position
+    # @return [EasyTalk::Types::Tuple] A new Tuple instance
+    def self.[](*types)
+      EasyTalk::Types::Tuple.new(*types)
+    end
+  end
+end