typed_attrs 0.1.0

data/lib/typed_attrs/type_processors/array.rb

@@ -0,0 +1,88 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Array < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec.is_a?(T::Types::TypedArray)
+      end
+
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        super
+        @element_type = T.let(extract_element_type(type_spec), T.untyped)
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Array[T.untyped]) }
+      def serialize(value)
+        unless value.is_a?(::Array)
+          raise TypedAttrs::TypeMismatchError.new("Expected Array, got #{value.class}", value: value)
+        end
+
+        value.map do |item|
+          serialize_item(item)
+        end
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Array[T.untyped]) }
+      def deserialize(value)
+        unless value.is_a?(::Array)
+          raise TypedAttrs::DeserializationError.new("Expected Array, got #{value.class}", value: value)
+        end
+
+        value.map do |item|
+          deserialize_item(item)
+        end
+      end
+
+      sig do
+        override.params(
+          value: T.untyped,
+          path: ::String,
+          blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: ::String).void
+        ).void
+      end
+      def traverse(value, path: "", &blk)
+        super
+
+        unless value.is_a?(::Array)
+          raise TypedAttrs::TypeMismatchError.new("Expected Array, got #{value.class}", value: value)
+        end
+
+        value.each_with_index do |item, index|
+          item_processor = @registry.serializer_for(@element_type)
+          item_path = "#{path}[#{index}]"
+          item_processor.traverse(item, path: item_path, &blk)
+        end
+      end
+
+      private
+
+      sig { params(item: T.untyped).returns(T.untyped) }
+      def serialize_item(item)
+        serializer = @registry.serializer_for(@element_type)
+        serializer.serialize(item)
+      end
+
+      sig { params(item: T.untyped).returns(T.untyped) }
+      def deserialize_item(item)
+        serializer = @registry.serializer_for(@element_type)
+        serializer.deserialize(item)
+      end
+
+      sig { params(type_spec: T.untyped).returns(T.untyped) }
+      def extract_element_type(type_spec)
+        case type_spec
+        when T::Types::TypedArray
+          type_spec.type
+        else
+          raise ArgumentError, "Expected T::Types::TypedArray, got #{type_spec.class}"
+        end
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/base.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Base
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { overridable.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        raise NotImplementedError, "#{self}.handles? must be implemented"
+      end
+
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        @type_spec = type_spec
+        @registry = T.let(registry, Registry)
+      end
+
+      sig { overridable.params(value: T.untyped).returns(T.untyped) }
+      def serialize(value)
+        raise NotImplementedError, "#{self.class}#serialize must be implemented"
+      end
+
+      sig { overridable.params(value: T.untyped).returns(T.untyped) }
+      def deserialize(value)
+        raise NotImplementedError, "#{self.class}#deserialize must be implemented"
+      end
+
+      sig do
+        overridable.params(
+          value: T.untyped,
+          path: ::String,
+          blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: ::String).void
+        ).void
+      end
+      def traverse(value, path: "", &blk)
+        blk.call(@type_spec, value, path)
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/boolean.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Boolean < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == T::Boolean
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Boolean) }
+      def serialize(value)
+        unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected TrueClass or FalseClass, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Boolean) }
+      def deserialize(value)
+        unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected TrueClass or FalseClass, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/boolean_primitive.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class BooleanPrimitive < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        [TrueClass, FalseClass].include?(type_spec)
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Boolean) }
+      def serialize(value)
+        unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected TrueClass or FalseClass, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Boolean) }
+      def deserialize(value)
+        unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected TrueClass or FalseClass, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/date.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Date < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == ::Date
+      end
+
+      sig { override.params(value: T.untyped).returns(::String) }
+      def serialize(value)
+        unless value.is_a?(::Date)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected Date, got #{value.class}",
+            value: value
+          )
+        end
+
+        value.iso8601
+      end
+
+      sig { override.params(value: T.untyped).returns(::Date) }
+      def deserialize(value)
+        case value
+        when ::Date
+          value
+        when ::String
+          ::Date.iso8601(value)
+        else
+          raise TypedAttrs::DeserializationError.new(
+            "Expected Date or String, got #{value.class}",
+            value: value
+          )
+        end
+      rescue ArgumentError => e
+        raise TypedAttrs::DeserializationError.new(
+          "Failed to deserialize Date: #{e.message}",
+          value: value
+        )
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/discriminated_union.rb

@@ -0,0 +1,211 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class DiscriminatedUnion < Base
+      extend T::Sig
+      extend TypeHelpers
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        UnionModule.union_module?(type_spec)
+      end
+
+      # discriminated_union_module must extend TypedAttrs::DiscriminatedUnion
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        super
+
+        @union_module = T.let(UnionModule.new(type_spec), UnionModule)
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Hash[::String, T.untyped]) }
+      def serialize(value)
+        struct_class = @union_module.find_struct_class_by_instance(value)
+
+        unless struct_class
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected one of [#{@union_module.types_string}], got #{value.class}",
+            value: value
+          )
+        end
+
+        serializer = @registry.serializer_for(value.class)
+        hash = serializer.serialize(value)
+
+        discriminator_value = @union_module.discriminator_value_for(value.class)
+        raise StandardError, "No discriminator value found for #{value.class}" unless discriminator_value
+
+        hash[@union_module.discriminator_key] = discriminator_value
+        hash
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Struct) }
+      def deserialize(value)
+        return value if @union_module.find_struct_class_by_instance(value)
+
+        unless value.is_a?(::Hash)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected Hash, got #{value.class}",
+            value: value
+          )
+        end
+
+        discriminator_value = value[@union_module.discriminator_key] || value[@union_module.discriminator_key.to_sym]
+        unless discriminator_value
+          raise TypedAttrs::DeserializationError.new(
+            "Missing discriminator key '#{@union_module.discriminator_key}' in hash",
+            value: value
+          )
+        end
+
+        struct_class = @union_module.find_struct_class_by_discriminator_value(discriminator_value)
+
+        unless struct_class
+          raise TypedAttrs::DeserializationError.new(
+            "Unknown discriminator value '#{discriminator_value}' for key '#{@union_module.discriminator_key}'. ",
+            value: value
+          )
+        end
+
+        hash_without_discriminator = value.dup
+        hash_without_discriminator.delete(@union_module.discriminator_key)
+        hash_without_discriminator.delete(@union_module.discriminator_key.to_sym)
+
+        serializer = @registry.serializer_for(struct_class)
+        serializer.deserialize(hash_without_discriminator)
+      end
+
+      sig do
+        override.params(
+          value: T.untyped,
+          path: ::String,
+          blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: ::String).void
+        ).void
+      end
+      def traverse(value, path: "", &blk)
+        super
+
+        unless @union_module.find_struct_class_by_instance(value)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected one of [#{@union_module.types_string}], got #{value.class}",
+            value: value
+          )
+        end
+
+        actual_processor = @registry.serializer_for(value.class)
+        actual_processor.traverse(value, path: path, &blk)
+      end
+
+      private
+
+      sig { params(struct_classes: T::Array[T.class_of(T::Struct)]).returns(T::Hash[T.class_of(T::Struct), ::String]) }
+      def build_discriminator_map(struct_classes)
+        struct_classes.to_h do |klass|
+          unless respond_to?(:discriminator)
+            raise TypedAttrs::MissingDiscriminatorValueError.new(klass) # rubocop:disable Style/RaiseArgs
+          end
+
+          value = T.unsafe(klass).discriminator
+
+          unless value
+            raise TypedAttrs::MissingDiscriminatorValueError.new(klass) # rubocop:disable Style/RaiseArgs
+          end
+
+          [klass, value]
+        end
+      end
+    end
+
+    class UnionModule
+      extend T::Sig
+
+      sig { params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.union_module?(type_spec)
+        return false unless type_spec.is_a?(Module)
+        return false unless type_spec.respond_to?(:sealed_subclasses)
+        return false unless type_spec.respond_to?(:_get_discriminator_key)
+
+        true
+      end
+
+      sig { params(type_spec: T.untyped).void }
+      def initialize(type_spec)
+        raise ArgumentError, "Not a union module" unless self.class.union_module?(type_spec)
+
+        @type_spec = type_spec
+
+        if type_spec._get_discriminator_key.nil?
+          raise TypedAttrs::MissingDiscriminatorKeyError.new(type_spec) # rubocop:disable Style/RaiseArgs
+        end
+
+        if type_spec.sealed_subclasses.empty?
+          raise TypedAttrs::EmptyUnionModuleError.new(type_spec) # rubocop:disable Style/RaiseArgs
+        end
+
+        @discriminator_key = T.let(type_spec._get_discriminator_key, ::String)
+        @discriminator_map = T.let(build_discriminator_map, T::Hash[T.class_of(T::Struct), ::String])
+        @reverse_map = T.let(@discriminator_map.invert, T::Hash[::String, T.class_of(T::Struct)])
+      end
+
+      sig { returns(::String) }
+      attr_reader :discriminator_key
+
+      sig { params(discriminator_value: T.any(::String, ::Symbol)).returns(T.nilable(T.class_of(T::Struct))) }
+      def find_struct_class_by_discriminator_value(discriminator_value)
+        @reverse_map[discriminator_value.to_s]
+      end
+
+      sig { params(struct_class: T.class_of(T::Struct)).returns(T.nilable(::String)) }
+      def discriminator_value_for(struct_class)
+        @discriminator_map[struct_class]
+      end
+
+      sig { params(klass: T.class_of(T::Struct)).returns(T.nilable(T.class_of(T::Struct))) }
+      def find_struct_class(klass)
+        struct_classes.find { |k| k == klass }
+      end
+
+      sig { params(instance: T.untyped).returns(T.nilable(T.class_of(T::Struct))) }
+      def find_struct_class_by_instance(instance)
+        struct_classes.find { |k| k == instance.class }
+      end
+
+      sig { returns(::String) }
+      def types_string
+        struct_classes.map(&:name).join(", ")
+      end
+
+      private
+
+      sig { returns(T::Hash[T.class_of(T::Struct), ::String]) }
+      def build_discriminator_map
+        struct_classes.to_h do |klass|
+          unless klass.respond_to?(:discriminator)
+            raise TypedAttrs::MissingDiscriminatorValueError.new(klass) # rubocop:disable Style/RaiseArgs
+          end
+
+          value = T.unsafe(klass).discriminator
+
+          unless value
+            raise TypedAttrs::MissingDiscriminatorValueError.new(klass) # rubocop:disable Style/RaiseArgs
+          end
+
+          [klass, value]
+        end
+      end
+
+      sig { returns(T::Array[T.class_of(T::Struct)]) }
+      def struct_classes
+        T.let(
+          T.cast(
+            @type_spec.sealed_subclasses.select { |k| k < T::Struct },
+            T::Array[T.class_of(T::Struct)]
+          ),
+          T::Array[T.class_of(T::Struct)]
+        )
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/float.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Float < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == ::Float
+      end
+
+      sig { override.params(value: T.untyped).returns(::Float) }
+      def serialize(value)
+        unless value.is_a?(::Float)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected Float, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+
+      sig { override.params(value: T.untyped).returns(::Float) }
+      def deserialize(value)
+        case value
+        when ::Float
+          value
+        when ::Integer
+          value.to_f
+        else
+          raise TypedAttrs::DeserializationError.new(
+            "Expected Float or Integer, got #{value.class}",
+            value: value
+          )
+        end
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/hash.rb

@@ -0,0 +1,116 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Hash < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec.is_a?(T::Types::TypedHash)
+      end
+
+      sig { params(type_spec: T.untyped, registry: Registry).void }
+      def initialize(type_spec, registry:)
+        super
+        @key_type = T.let(extract_key_type(type_spec), T.untyped)
+        @value_type = T.let(extract_value_type(type_spec), T.untyped)
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Hash[::String, T.untyped]) }
+      def serialize(value)
+        unless value.is_a?(::Hash)
+          raise TypedAttrs::TypeMismatchError.new("Expected Hash, got #{value.class}", value: value)
+        end
+
+        result = {}
+        value.each do |key, item|
+          string_key = key.to_s
+          result[string_key] = serialize_value(item)
+        end
+        result
+      end
+
+      sig { override.params(value: T.untyped).returns(T::Hash[::String, T.untyped]) }
+      def deserialize(value)
+        unless value.is_a?(::Hash)
+          raise TypedAttrs::DeserializationError.new("Expected Hash, got #{value.class}", value: value)
+        end
+
+        result = {}
+        value.each do |key, item|
+          normalized_key = if @key_type == ::String
+                             key.to_s
+                           elsif @key_type == ::Symbol
+                             key.to_sym
+                           else
+                             key
+                           end
+          result[normalized_key] = deserialize_value(item)
+        end
+        result
+      end
+
+      sig do
+        override.params(
+          value: T.untyped,
+          path: ::String,
+          blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: ::String).void
+        ).void
+      end
+      def traverse(value, path: "", &blk)
+        super
+
+        unless value.is_a?(::Hash)
+          raise TypedAttrs::TypeMismatchError.new("Expected Hash, got #{value.class}", value: value)
+        end
+
+        value.each do |key, val|
+          value_processor = @registry.serializer_for(@value_type)
+          val_path = path.empty? ? key.to_s : "#{path}.#{key}"
+          value_processor.traverse(val, path: val_path, &blk)
+        end
+      end
+
+      private
+
+      sig { params(item: T.untyped).returns(T.untyped) }
+      def serialize_value(item)
+        serializer = @registry.serializer_for(@value_type)
+        serializer.serialize(item)
+      end
+
+      sig { params(item: T.untyped).returns(T.untyped) }
+      def deserialize_value(item)
+        serializer = @registry.serializer_for(@value_type)
+        serializer.deserialize(item)
+      end
+
+      sig { params(type_spec: T.untyped).returns(T.untyped) }
+      def extract_key_type(type_spec)
+        case type_spec
+        when T::Types::TypedHash
+          key_type = type_spec.keys
+          if key_type.is_a?(T::Types::Simple)
+            T.unsafe(key_type).raw_type
+          else
+            key_type
+          end
+        else
+          raise ArgumentError, "Expected T::Types::TypedHash, got #{type_spec.class}"
+        end
+      end
+
+      sig { params(type_spec: T.untyped).returns(T.untyped) }
+      def extract_value_type(type_spec)
+        case type_spec
+        when T::Types::TypedHash
+          type_spec.values
+        else
+          raise ArgumentError, "Expected T::Types::TypedHash, got #{type_spec.class}"
+        end
+      end
+    end
+  end
+end

data/lib/typed_attrs/type_processors/integer.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module TypedAttrs
+  module TypeProcessors
+    class Integer < Base
+      extend T::Sig
+
+      sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+      def self.handles?(type_spec)
+        type_spec == ::Integer
+      end
+
+      sig { override.params(value: T.untyped).returns(::Integer) }
+      def serialize(value)
+        unless value.is_a?(::Integer)
+          raise TypedAttrs::TypeMismatchError.new(
+            "Expected Integer, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+
+      sig { override.params(value: T.untyped).returns(::Integer) }
+      def deserialize(value)
+        unless value.is_a?(::Integer)
+          raise TypedAttrs::DeserializationError.new(
+            "Expected Integer, got #{value.class}",
+            value: value
+          )
+        end
+
+        value
+      end
+    end
+  end
+end