skit 0.1.0

data/lib/skit/serialization/processor/json_schema_const.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class JsonSchemaConst < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          return false unless type_spec.is_a?(Class)
+
+          !!(type_spec < Skit::JsonSchema::Types::Const)
+        end
+
+        sig { params(type_spec: T.untyped, registry: Registry).void }
+        def initialize(type_spec, registry:)
+          super
+          unless type_spec.is_a?(Class) && type_spec < Skit::JsonSchema::Types::Const
+            raise ArgumentError, "Expected Skit::JsonSchema::Types::Const subclass, got #{type_spec}"
+          end
+
+          @const_class = T.let(type_spec, T.class_of(Skit::JsonSchema::Types::Const))
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def serialize(value, path: Path.new)
+          unless value.is_a?(@const_class)
+            raise SerializeError.new("Expected #{@const_class}, got #{value.class}",
+                                     path: path)
+          end
+
+          value.value
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(Skit::JsonSchema::Types::Const) }
+        def deserialize(value, path: Path.new)
+          return value if value.is_a?(@const_class)
+
+          expected = @const_class.value
+
+          unless value == expected
+            raise DeserializeError.new(
+              "Expected #{expected.inspect}, got #{value.inspect} for #{@const_class}",
+              path: path
+            )
+          end
+
+          @const_class.new
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/nilable.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class Nilable < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          nilable_type?(type_spec)
+        end
+
+        sig { params(type_spec: T.untyped, registry: Registry).void }
+        def initialize(type_spec, registry:)
+          super
+          unless self.class.nilable_type?(type_spec)
+            raise ArgumentError,
+                  "Expected nilable type, got #{type_spec.class}"
+          end
+
+          @inner_type = T.let(extract_inner_type(type_spec), T.untyped)
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def serialize(value, path: Path.new)
+          return nil if value.nil?
+
+          processor = @registry.processor_for(@inner_type)
+          processor.serialize(value, path: path)
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def deserialize(value, path: Path.new)
+          return nil if value.nil?
+
+          processor = @registry.processor_for(@inner_type)
+          processor.deserialize(value, path: path)
+        end
+
+        sig do
+          override.params(
+            value: T.untyped,
+            path: Path,
+            blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: Path).void
+          ).void
+        end
+        def traverse(value, path: Path.new, &blk)
+          super
+
+          return if value.nil?
+
+          processor = @registry.processor_for(@inner_type)
+          processor.traverse(value, path: path, &blk)
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { params(type_object: T.untyped).returns(T::Boolean) }
+          def nilable_type?(type_object)
+            return false unless type_object.is_a?(T::Types::Union)
+
+            types = type_object.types
+            has_nil = types.any? { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
+            non_nil_count = types.count { |t| !(t.is_a?(T::Types::Simple) && t.raw_type == NilClass) }
+
+            has_nil && non_nil_count == 1
+          end
+        end
+
+        private
+
+        sig { params(nilable_type: T.untyped).returns(T.untyped) }
+        def extract_inner_type(nilable_type)
+          types = nilable_type.types
+          non_nil_types = types.reject { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
+
+          raise ArgumentError, "T.nilable must have exactly one non-nil type" if non_nil_types.length != 1
+
+          non_nil_types.first
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/simple_type.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class SimpleType < 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::Simple)
+        end
+
+        sig { params(type_spec: T.untyped, registry: Registry).void }
+        def initialize(type_spec, registry:)
+          super
+          unless type_spec.is_a?(T::Types::Simple)
+            raise ArgumentError, "Expected T::Types::Simple, got #{type_spec.class}"
+          end
+
+          @raw_type = T.let(type_spec.raw_type, T.untyped)
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def serialize(value, path: Path.new)
+          processor = @registry.processor_for(@raw_type)
+          processor.serialize(value, path: path)
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def deserialize(value, path: Path.new)
+          processor = @registry.processor_for(@raw_type)
+          processor.deserialize(value, path: path)
+        end
+
+        sig do
+          override.params(
+            value: T.untyped,
+            path: Path,
+            blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: Path).void
+          ).void
+        end
+        def traverse(value, path: Path.new, &blk)
+          processor = @registry.processor_for(@raw_type)
+          processor.traverse(value, path: path, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/string.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class String < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          type_spec == ::String
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::String) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected String, got #{value.class}", path: path) unless value.is_a?(::String)
+
+          value
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::String) }
+        def deserialize(value, path: Path.new)
+          raise DeserializeError.new("Expected String, got #{value.class}", path: path) unless value.is_a?(::String)
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/struct.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class Struct < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          return false unless type_spec.is_a?(Class)
+
+          !!(type_spec < T::Struct)
+        end
+
+        sig { params(type_spec: T.untyped, registry: Registry).void }
+        def initialize(type_spec, registry:)
+          super
+          unless type_spec.is_a?(Class) && type_spec < T::Struct
+            raise ArgumentError, "Expected T::Struct, got #{type_spec}"
+          end
+
+          @struct_class = T.let(type_spec, T.class_of(T::Struct))
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Hash[::String, T.untyped]) }
+        def serialize(value, path: Path.new)
+          unless value.is_a?(@struct_class)
+            raise SerializeError.new("Expected #{@struct_class}, got #{value.class}",
+                                     path: path)
+          end
+
+          @struct_class.props.each_with_object({}) do |(name, prop_def), hash|
+            prop_value = value.public_send(name)
+            prop_type = prop_def[:type_object]
+            processor = @registry.processor_for(prop_type)
+            hash[name.to_s] = processor.serialize(prop_value, path: path.append(name.to_s))
+          end
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Struct) }
+        def deserialize(value, path: Path.new)
+          return value if value.is_a?(@struct_class)
+
+          raise DeserializeError.new("Expected Hash, got #{value.class}", path: path) unless value.is_a?(::Hash)
+
+          symbolized = value.transform_keys(&:to_sym)
+
+          deserialized = @struct_class.props.each_with_object({}) do |(name, prop_def), hash|
+            next unless symbolized.key?(name)
+
+            prop_value = symbolized[name]
+            prop_type = prop_def[:type_object]
+            processor = @registry.processor_for(prop_type)
+            hash[name] = processor.deserialize(prop_value, path: path.append(name.to_s))
+          end
+
+          @struct_class.new(**deserialized)
+        end
+
+        sig do
+          override.params(
+            value: T.untyped,
+            path: Path,
+            blk: T.proc.params(type_spec: T.untyped, node: T.untyped, path: Path).void
+          ).void
+        end
+        def traverse(value, path: Path.new, &blk)
+          super
+
+          return unless value.is_a?(@struct_class)
+
+          @struct_class.props.each do |name, prop_def|
+            prop_value = value.public_send(name)
+            prop_type = prop_def[:type_object]
+            processor = @registry.processor_for(prop_type)
+            processor.traverse(prop_value, path: path.append(name.to_s), &blk)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/symbol.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class Symbol < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          type_spec == ::Symbol
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::String) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Symbol, got #{value.class}", path: path) unless value.is_a?(::Symbol)
+
+          value.to_s
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::Symbol) }
+        def deserialize(value, path: Path.new)
+          return value if value.is_a?(::Symbol)
+
+          unless value.is_a?(::String)
+            raise DeserializeError.new("Expected String or Symbol, got #{value.class}",
+                                       path: path)
+          end
+
+          value.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/time.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "time"
+
+module Skit
+  module Serialization
+    module Processor
+      class Time < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          type_spec == ::Time
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::String) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Time, got #{value.class}", path: path) unless value.is_a?(::Time)
+
+          value.iso8601
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::Time) }
+        def deserialize(value, path: Path.new)
+          case value
+          when ::Time
+            value
+          when ::String
+            ::Time.iso8601(value)
+          else
+            raise DeserializeError.new("Expected Time or String, got #{value.class}", path: path)
+          end
+        rescue ArgumentError => e
+          raise DeserializeError.new("Failed to deserialize Time: #{e.message}", path: path)
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/processor/union.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class Union < Base
+        extend T::Sig
+
+        sig { override.params(type_spec: T.untyped).returns(T::Boolean) }
+        def self.handles?(type_spec)
+          return false unless type_spec.is_a?(T::Types::Union)
+          return false if contains_nil_class?(type_spec)
+          return false if boolean_union?(type_spec)
+
+          struct_types(type_spec).length == type_spec.types.length
+        end
+
+        sig { params(type_spec: T.untyped, registry: Registry).void }
+        def initialize(type_spec, registry:)
+          super
+          @struct_classes = T.let(
+            self.class.struct_types(type_spec),
+            T::Array[T.class_of(T::Struct)]
+          )
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Hash[::String, T.untyped]) }
+        def serialize(value, path: Path.new)
+          struct_class = find_struct_class_for_value(value)
+
+          unless struct_class
+            raise SerializeError.new(
+              "#{value.class} is not a member of this union: #{@struct_classes.map(&:name).join(", ")}",
+              path: path
+            )
+          end
+
+          processor = @registry.processor_for(struct_class)
+          processor.serialize(value, path: path)
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def deserialize(value, path: Path.new)
+          return value if value_is_union_member?(value)
+
+          unless value.is_a?(::Hash)
+            raise DeserializeError.new("Expected Hash or union member struct, got #{value.class}",
+                                       path: path)
+          end
+
+          @struct_classes.each do |struct_class|
+            result = try_deserialize(value, struct_class, path: path)
+            return result if result
+          end
+
+          raise DeserializeError.new(
+            "No matching struct found for union: #{@struct_classes.map(&:name).join(", ")}",
+            path: path
+          )
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { params(type_spec: T.untyped).returns(T::Boolean) }
+          def contains_nil_class?(type_spec)
+            type_spec.types.any? do |t|
+              t.is_a?(T::Types::Simple) && t.raw_type == NilClass
+            end
+          end
+
+          sig { params(type_spec: T.untyped).returns(T::Boolean) }
+          def boolean_union?(type_spec)
+            raw_types = type_spec.types.filter_map do |t|
+              t.is_a?(T::Types::Simple) ? t.raw_type : nil
+            end
+            raw_types.sort_by { |t| t.name.to_s } == [FalseClass, TrueClass]
+          end
+
+          sig { params(type_spec: T.untyped).returns(T::Array[T.class_of(T::Struct)]) }
+          def struct_types(type_spec)
+            type_spec.types.filter_map do |t|
+              next unless t.is_a?(T::Types::Simple)
+
+              klass = t.raw_type
+              klass if klass.is_a?(Class) && klass < T::Struct
+            end
+          end
+        end
+
+        private
+
+        sig { params(value: T.untyped).returns(T.nilable(T.class_of(T::Struct))) }
+        def find_struct_class_for_value(value)
+          @struct_classes.find { |klass| value.is_a?(klass) }
+        end
+
+        sig { params(value: T.untyped).returns(T::Boolean) }
+        def value_is_union_member?(value)
+          @struct_classes.any? { |klass| value.is_a?(klass) }
+        end
+
+        sig do
+          params(
+            value: T::Hash[T.untyped, T.untyped],
+            struct_class: T.class_of(T::Struct),
+            path: Path
+          ).returns(T.nilable(T::Struct))
+        end
+        def try_deserialize(value, struct_class, path: Path.new)
+          processor = @registry.processor_for(struct_class)
+          processor.deserialize(value, path: path)
+        rescue SerializeError, DeserializeError, ArgumentError, TypeError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization/registry.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    class Registry
+      extend T::Sig
+
+      sig { void }
+      def initialize
+        @processors = T.let([], T::Array[T.class_of(Processor::Base)])
+      end
+
+      sig { params(processor_class: T.class_of(Processor::Base)).void }
+      def register(processor_class)
+        @processors << processor_class
+      end
+
+      sig { params(type_spec: T.untyped).returns(T.class_of(Processor::Base)) }
+      def find_processor(type_spec)
+        processor_class = @processors.find { |p| p.handles?(type_spec) }
+        raise UnknownTypeError, "No processor for #{type_spec}" unless processor_class
+
+        processor_class
+      end
+
+      sig { params(type_spec: T.untyped).returns(Processor::Base) }
+      def processor_for(type_spec)
+        find_processor(type_spec).new(type_spec, registry: self)
+      end
+    end
+  end
+end

data/lib/skit/serialization.rb

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "serialization/errors"
+require_relative "serialization/path"
+require_relative "serialization/processor/base"
+require_relative "serialization/registry"
+
+# Processors
+require_relative "serialization/processor/string"
+require_relative "serialization/processor/integer"
+require_relative "serialization/processor/float"
+require_relative "serialization/processor/boolean"
+require_relative "serialization/processor/symbol"
+require_relative "serialization/processor/date"
+require_relative "serialization/processor/time"
+require_relative "serialization/processor/struct"
+require_relative "serialization/processor/simple_type"
+require_relative "serialization/processor/array"
+require_relative "serialization/processor/hash"
+require_relative "serialization/processor/nilable"
+require_relative "serialization/processor/union"
+require_relative "serialization/processor/json_schema_const"
+require_relative "serialization/processor/enum"
+
+module Skit
+  module Serialization
+    extend T::Sig
+
+    sig { returns(Registry) }
+    def self.default_registry
+      @default_registry ||= T.let(build_default_registry, T.nilable(Registry))
+      @default_registry
+    end
+
+    sig { returns(Registry) }
+    def self.build_default_registry
+      registry = Registry.new
+      # Register processors in order of specificity (most specific first)
+      registry.register(Processor::Nilable)
+      registry.register(Processor::Union)
+      registry.register(Processor::Array)
+      registry.register(Processor::Hash)
+      registry.register(Processor::JsonSchemaConst)
+      registry.register(Processor::Enum)
+      registry.register(Processor::Struct)
+      registry.register(Processor::SimpleType)
+      registry.register(Processor::Date)
+      registry.register(Processor::Time)
+      registry.register(Processor::String)
+      registry.register(Processor::Integer)
+      registry.register(Processor::Float)
+      registry.register(Processor::Boolean)
+      registry.register(Processor::Symbol)
+      registry
+    end
+
+    private_class_method :build_default_registry
+  end
+end

data/lib/skit/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  VERSION = "0.1.0"
+end

data/lib/skit.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Skit
+  class Error < StandardError; end
+end
+
+require_relative "skit/version"
+# Load JsonSchema::Types::Const early so it can be used by serialization processors
+require_relative "skit/json_schema/types/const"
+require_relative "skit/serialization"
+require_relative "skit/attribute"
+require_relative "skit/json_schema"
+require_relative "active_model/validations/skit_validator"
+
+module Skit # rubocop:disable Style/OneClassPerFile
+  extend T::Sig
+
+  # Serialize a T::Struct instance to a Hash with string keys.
+  #
+  # @param struct [T::Struct] The struct instance to serialize
+  # @return [Hash] The serialized Hash
+  # @raise [Serialization::SerializeError] If the value is not a T::Struct
+  sig { params(struct: T::Struct).returns(T::Hash[::String, T.untyped]) }
+  def self.serialize(struct)
+    struct_class = struct.class
+    raise Serialization::SerializeError, "Expected T::Struct, got #{struct_class}" unless struct_class < T::Struct
+
+    processor = Serialization.default_registry.processor_for(struct_class)
+    processor.serialize(struct)
+  end
+
+  # Deserialize a Hash to a T::Struct instance.
+  #
+  # @param hash [Hash] The hash to deserialize
+  # @param type [Class] The T::Struct class to deserialize to
+  # @return [T::Struct] The deserialized struct instance
+  # @raise [Serialization::DeserializeError] If deserialization fails
+  sig { params(hash: T.untyped, type: T.class_of(T::Struct)).returns(T::Struct) }
+  def self.deserialize(hash, type)
+    processor = Serialization.default_registry.processor_for(type)
+    processor.deserialize(hash)
+  end
+end