skit 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cc33f58131c2335f5dad719b28ea332d0f79f2c449009197c918807337c7516
-  data.tar.gz: 5c2f69177a3080487c122fec666c097faa46ea08eccacdc427aec38b9eb467ca
+  metadata.gz: 6be21ee56f12e3c9f8423fa6f2c7c78c037b343da6fe28f22d671c6f4c14f63c
+  data.tar.gz: e321613784a55eafc86ac36fce373389ce9cfa95952f4a72d5c14ca4a5f4baa2
 SHA512:
-  metadata.gz: 2ce51b62c7eaa852e78500c2626b072d3b0c37b96182c2d71787c266449afd8300849f83e60cf31d0934058607b1a626ec90efbd36e3307bcb1c304cb35f08b2
-  data.tar.gz: 408211448ab4abd8c0cbe498bc9a49b9c2e39ea3b1a0a9b592fedf00c845a90bcb878ba144cdbbb6647dc0c8b0590a8192682b91900c421376b4f848d0381c62
+  metadata.gz: d9638fe3360d250991fc3515e5aff65ae189e71121cbf6e9f4ae93873e00ada3918a831aff0abf27962697f07d35d8ce39731284c8af92a3fce05c8645f9344b
+  data.tar.gz: 8380a8ffe62a99b4916c0a77b1ff53a491152bf2457af6ffa54ad0be226ee30727e74bdece9cd45240160f819384eee11b138e131fce92cbd577ddc073d471d8

data/lib/skit/json_schema/definitions/property_types.rb

@@ -6,7 +6,8 @@ module Skit
     module Definitions
       # Type alias: Union type of PropertyType-related classes
       PropertyTypes = T.type_alias do
-        T.any(PropertyType, ArrayPropertyType, HashPropertyType, UnionPropertyType, ConstType, EnumType)
+        T.any(PropertyType, ArrayPropertyType, HashPropertyType, UnionPropertyType, ConstType, EnumType,
+              TuplePropertyType)
       end
     end
   end

data/lib/skit/json_schema/definitions/struct.rb

@@ -73,6 +73,10 @@ module Skit
           case property_type
           when ArrayPropertyType
             types.concat(extract_types_from_property_type(property_type.item_type))
+          when TuplePropertyType
+            property_type.item_types.each do |item_type|
+              types.concat(extract_types_from_property_type(item_type))
+            end
           when HashPropertyType
             types.concat(extract_types_from_property_type(property_type.value_type))
           when UnionPropertyType

data/lib/skit/json_schema/definitions/tuple_property_type.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      class TuplePropertyType
+        extend T::Sig
+
+        sig { returns(T::Array[PropertyTypes]) }
+        attr_reader :item_types
+
+        sig { returns(T::Boolean) }
+        attr_reader :nullable
+
+        sig { params(item_types: T::Array[PropertyTypes], nullable: T::Boolean).void }
+        def initialize(item_types:, nullable: false)
+          @item_types = item_types
+          @nullable = nullable
+        end
+
+        sig { returns(String) }
+        def to_sorbet_type
+          tuple_type = "[#{@item_types.map(&:to_sorbet_type).join(", ")}]"
+          nullable ? "T.nilable(#{tuple_type})" : tuple_type
+        end
+
+        sig { returns(TuplePropertyType) }
+        def with_nullable
+          TuplePropertyType.new(item_types: @item_types, nullable: true)
+        end
+      end
+    end
+  end
+end

data/lib/skit/json_schema/schema_analyzer.rb

@@ -312,14 +312,26 @@ module Skit
         end
       end
 
-      sig { params(schema: T::Hash[String, T.untyped], class_name_path: ClassNamePath).returns(Definitions::ArrayPropertyType) }
+      sig do
+        params(
+          schema: T::Hash[String, T.untyped],
+          class_name_path: ClassNamePath
+        ).returns(T.any(Definitions::ArrayPropertyType, Definitions::TuplePropertyType))
+      end
       def build_array_type(schema, class_name_path)
-        if schema["items"]
-          item_schema = T.cast(schema["items"], T::Hash[String, T.untyped])
-          item_type = build_property_type(item_schema, class_name_path.append("item"))
+        # Support both prefixItems (2020-12) and items-as-array (draft-04/07) for tuple validation
+        tuple_items = schema["prefixItems"] || (schema["items"].is_a?(::Array) ? schema["items"] : nil)
+
+        if tuple_items
+          item_types = tuple_items.each_with_index.map do |item_schema, index|
+            item_schema_typed = T.cast(item_schema, T::Hash[String, T.untyped])
+            build_property_type(item_schema_typed, class_name_path.append("item#{index}"))
+          end
+          Definitions::TuplePropertyType.new(item_types: item_types)
+        elsif schema["items"].is_a?(::Hash)
+          item_type = build_property_type(schema["items"], class_name_path.append("item"))
           Definitions::ArrayPropertyType.new(item_type: item_type)
         else
-          # Array of T.untyped when items is not specified
           untyped_item = Definitions::PropertyType.new(base_type: "T.untyped")
           Definitions::ArrayPropertyType.new(item_type: untyped_item)
         end

data/lib/skit/json_schema.rb

@@ -7,6 +7,7 @@ require_relative "json_schema/definitions/property_type"
 require_relative "json_schema/definitions/const_type"
 require_relative "json_schema/definitions/enum_type"
 require_relative "json_schema/definitions/property_types"
+require_relative "json_schema/definitions/tuple_property_type"
 require_relative "json_schema/definitions/array_property_type"
 require_relative "json_schema/definitions/hash_property_type"
 require_relative "json_schema/definitions/union_property_type"

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

@@ -0,0 +1,78 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class Tuple < 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::FixedArray)
+        end
+
+        sig { params(type_spec: T.untyped, registry: Registry).void }
+        def initialize(type_spec, registry:)
+          super
+          unless type_spec.is_a?(T::Types::FixedArray)
+            raise ArgumentError, "Expected T::Types::FixedArray, got #{type_spec.class}"
+          end
+
+          @element_types = T.let(type_spec.types, T::Array[T.untyped])
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Array[T.untyped]) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Array, got #{value.class}", path: path) unless value.is_a?(::Array)
+
+          value.each_with_index.map do |item, index|
+            element_type = @element_types[index]
+            if element_type
+              processor = @registry.processor_for(element_type)
+              processor.serialize(item, path: path.append(index))
+            else
+              item
+            end
+          end
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Array[T.untyped]) }
+        def deserialize(value, path: Path.new)
+          raise DeserializeError.new("Expected Array, got #{value.class}", path: path) unless value.is_a?(::Array)
+
+          value.each_with_index.map do |item, index|
+            element_type = @element_types[index]
+            if element_type
+              processor = @registry.processor_for(element_type)
+              processor.deserialize(item, path: path.append(index))
+            else
+              item
+            end
+          end
+        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?(::Array)
+
+          value.each_with_index do |item, index|
+            element_type = @element_types[index]
+            if element_type
+              processor = @registry.processor_for(element_type)
+              processor.traverse(item, path: path.append(index), &blk)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skit/serialization.rb

@@ -16,6 +16,7 @@ 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/tuple"
 require_relative "serialization/processor/array"
 require_relative "serialization/processor/hash"
 require_relative "serialization/processor/nilable"
@@ -39,6 +40,7 @@ module Skit
       # Register processors in order of specificity (most specific first)
       registry.register(Processor::Nilable)
       registry.register(Processor::Union)
+      registry.register(Processor::Tuple)
       registry.register(Processor::Array)
       registry.register(Processor::Hash)
       registry.register(Processor::JsonSchemaConst)

data/lib/skit/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Skit
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skit
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Speria, inc.
@@ -81,6 +81,7 @@ files:
 - lib/skit/json_schema/definitions/property_types.rb
 - lib/skit/json_schema/definitions/struct.rb
 - lib/skit/json_schema/definitions/struct_property.rb
+- lib/skit/json_schema/definitions/tuple_property_type.rb
 - lib/skit/json_schema/definitions/union_property_type.rb
 - lib/skit/json_schema/naming_utils.rb
 - lib/skit/json_schema/schema_analyzer.rb
@@ -103,6 +104,7 @@ files:
 - lib/skit/serialization/processor/struct.rb
 - lib/skit/serialization/processor/symbol.rb
 - lib/skit/serialization/processor/time.rb
+- lib/skit/serialization/processor/tuple.rb
 - lib/skit/serialization/processor/union.rb
 - lib/skit/serialization/registry.rb
 - lib/skit/version.rb