skit 0.1.0

data/lib/skit/json_schema/types/const.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Types
+      # Base class for JSON Schema const values.
+      #
+      # Subclasses should define a VALUE constant with the const value:
+      #
+      #   class Dog < Skit::JsonSchema::Types::Const
+      #     VALUE = "dog"
+      #   end
+      #
+      # This enables type-safe discriminated unions:
+      #
+      #   T.any(Dog, Cat)  # "dog" deserializes to Dog, "cat" to Cat
+      #
+      class Const
+        extend T::Sig
+
+        # Returns the const value defined in the subclass.
+        sig { returns(T.untyped) }
+        def self.value
+          # rubocop:disable Sorbet/ConstantsFromStrings
+          const_get(:VALUE)
+          # rubocop:enable Sorbet/ConstantsFromStrings
+        end
+
+        # Returns the const value for this instance.
+        sig { returns(T.untyped) }
+        def value
+          self.class.value
+        end
+
+        # Two Const instances are equal if they are of the same class.
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          other.is_a?(self.class)
+        end
+
+        # Alias for == to support Hash key comparison.
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def eql?(other)
+          self == other
+        end
+
+        # Hash code based on the class, so all instances of the same class
+        # have the same hash code.
+        sig { returns(Integer) }
+        def hash
+          self.class.hash
+        end
+
+        # Returns a string representation for debugging.
+        sig { returns(String) }
+        def inspect
+          "#<#{self.class.name} value=#{value.inspect}>"
+        end
+
+        # Returns the string representation (the const value as string).
+        sig { returns(String) }
+        def to_s
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/skit/json_schema.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "json_schema/types/const"
+require_relative "json_schema/naming_utils"
+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/array_property_type"
+require_relative "json_schema/definitions/hash_property_type"
+require_relative "json_schema/definitions/union_property_type"
+require_relative "json_schema/definitions/struct_property"
+require_relative "json_schema/definitions/struct"
+require_relative "json_schema/definitions/module"
+require_relative "json_schema/config"
+require_relative "json_schema/class_name_path"
+require_relative "json_schema/schema_analyzer"
+require_relative "json_schema/code_generator"
+require_relative "json_schema/cli"
+
+module Skit
+  module JsonSchema
+    extend T::Sig
+
+    # Generate Sorbet T::Struct code from JSON Schema
+    #
+    # @param schema [Hash] The JSON Schema hash
+    # @param options [Hash] Configuration options
+    # @option options [String] :class_name Class name for the root struct (optional)
+    # @option options [String] :module_name Module name to wrap the generated struct (optional)
+    # @option options [String] :typed_strictness Sorbet typing level ('ignore', 'false', 'true', 'strict', 'strong')
+    #
+    # @return [String] Generated Ruby/Sorbet code
+    #
+    # @example Basic usage
+    #   schema = { "type" => "object", "properties" => { "name" => { "type" => "string" } } }
+    #   code = Skit::JsonSchema.generate(schema, class_name: "User")
+    #   puts code
+    #
+    # @example With all options
+    #   code = Skit::JsonSchema.generate(
+    #     schema,
+    #     class_name: "User",
+    #     module_name: "MyModule",
+    #     typed_strictness: "strict"
+    #   )
+    sig do
+      params(
+        schema: T::Hash[String, T.untyped],
+        options: T::Hash[T.any(Symbol, String), T.untyped]
+      ).returns(String)
+    end
+    def self.generate(schema, options = {})
+      # Extract and validate options (support both symbol and string keys)
+      class_name = T.cast(options[:class_name] || options["class_name"], T.nilable(String))
+      module_name = T.cast(options[:module_name] || options["module_name"], T.nilable(String))
+      typed_strictness = T.cast(options[:typed_strictness] || options["typed_strictness"],
+                                T.nilable(String)) || "strict"
+
+      # Create config with smart defaults
+      config = Config.new(
+        class_name: class_name,
+        module_name: module_name,
+        typed_strictness: typed_strictness
+      )
+
+      # Analyze schema
+      analyzer = SchemaAnalyzer.new(schema, config)
+      module_definition = analyzer.analyze
+
+      # Generate code
+      generator = CodeGenerator.new(module_definition, config)
+      generator.generate
+    end
+  end
+end

data/lib/skit/serialization/errors.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    class Error < Skit::Error
+      extend T::Sig
+
+      sig { returns(Path) }
+      attr_reader :path
+
+      sig { params(message: ::String, path: Path).void }
+      def initialize(message = "", path: Path.new)
+        @path = T.let(path, Path)
+        super(path.empty? ? message : "#{message} (at #{path})")
+      end
+    end
+
+    class UnknownTypeError < Error; end
+    class SerializeError < Error; end
+    class DeserializeError < Error; end
+  end
+end

data/lib/skit/serialization/path.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    class Path
+      extend T::Sig
+
+      Segment = T.type_alias { T.any(::String, ::Integer) }
+
+      sig { params(segments: T::Array[Segment]).void }
+      def initialize(segments = [])
+        @segments = T.let(segments.freeze, T::Array[Segment])
+      end
+
+      sig { params(segment: Segment).returns(Path) }
+      def append(segment)
+        Path.new(@segments + [segment])
+      end
+
+      sig { returns(T::Array[Segment]) }
+      attr_reader :segments
+
+      sig { returns(T::Boolean) }
+      def empty?
+        @segments.empty?
+      end
+
+      sig { returns(::String) }
+      def to_s
+        result = +""
+        @segments.each do |segment|
+          case segment
+          when ::Integer
+            result << "[#{segment}]"
+          when ::String
+            result << "." unless result.empty?
+            result << segment
+          end
+        end
+        result.freeze
+      end
+
+      sig { returns(::String) }
+      def to_json_pointer
+        return "" if @segments.empty?
+
+        "/#{@segments.map { |s| s.to_s.gsub("~", "~0").gsub("/", "~1") }.join("/")}"
+      end
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other)
+        return false unless other.is_a?(Path)
+
+        @segments == other.segments
+      end
+
+      sig { returns(::Integer) }
+      def hash
+        @segments.hash
+      end
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def eql?(other)
+        self == other
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      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
+          unless type_spec.is_a?(T::Types::TypedArray)
+            raise ArgumentError, "Expected T::Types::TypedArray, got #{type_spec.class}"
+          end
+
+          @element_type = T.let(type_spec.type, 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|
+            processor = @registry.processor_for(@element_type)
+            processor.serialize(item, path: path.append(index))
+          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|
+            processor = @registry.processor_for(@element_type)
+            processor.deserialize(item, path: path.append(index))
+          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|
+            processor = @registry.processor_for(@element_type)
+            processor.traverse(item, path: path.append(index), &blk)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      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, path: Path).returns(T.untyped) }
+        def serialize(value, path: Path.new)
+          raise NotImplementedError, "#{self.class}#serialize must be implemented"
+        end
+
+        sig { overridable.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def deserialize(value, path: Path.new)
+          raise NotImplementedError, "#{self.class}#deserialize must be implemented"
+        end
+
+        sig do
+          overridable.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)
+          blk.call(@type_spec, value, path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      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, path: Path).returns(T::Boolean) }
+        def serialize(value, path: Path.new)
+          unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            raise SerializeError.new("Expected TrueClass or FalseClass, got #{value.class}", path: path)
+          end
+
+          value
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Boolean) }
+        def deserialize(value, path: Path.new)
+          unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            raise DeserializeError.new("Expected TrueClass or FalseClass, got #{value.class}", path: path)
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "date"
+
+module Skit
+  module Serialization
+    module Processor
+      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, path: Path).returns(::String) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Date, got #{value.class}", path: path) unless value.is_a?(::Date)
+
+          value.iso8601
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::Date) }
+        def deserialize(value, path: Path.new)
+          case value
+          when ::Date
+            value
+          when ::String
+            ::Date.iso8601(value)
+          else
+            raise DeserializeError.new("Expected Date or String, got #{value.class}", path: path)
+          end
+        rescue ArgumentError => e
+          raise DeserializeError.new("Failed to deserialize Date: #{e.message}", path: path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      class Enum < 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::Enum)
+        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::Enum
+            raise ArgumentError, "Expected T::Enum subclass, got #{type_spec}"
+          end
+
+          @enum_class = T.let(type_spec, T.class_of(T::Enum))
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T.untyped) }
+        def serialize(value, path: Path.new)
+          unless value.is_a?(@enum_class)
+            raise SerializeError.new("Expected #{@enum_class}, got #{value.class}",
+                                     path: path)
+          end
+
+          value.serialize
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Enum) }
+        def deserialize(value, path: Path.new)
+          return value if value.is_a?(@enum_class)
+
+          begin
+            @enum_class.deserialize(value)
+          rescue KeyError
+            valid_values = @enum_class.values.map(&:serialize)
+            raise DeserializeError.new(
+              "Invalid value #{value.inspect} for #{@enum_class}. Valid values: #{valid_values.inspect}",
+              path: path
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      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, path: Path).returns(::Float) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Float, got #{value.class}", path: path) unless value.is_a?(::Float)
+
+          value
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::Float) }
+        def deserialize(value, path: Path.new)
+          case value
+          when ::Float
+            value
+          when ::Integer
+            value.to_f
+          else
+            raise DeserializeError.new("Expected Float or Integer, got #{value.class}", path: path)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      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
+          unless type_spec.is_a?(T::Types::TypedHash)
+            raise ArgumentError, "Expected T::Types::TypedHash, got #{type_spec.class}"
+          end
+
+          @key_type = T.let(extract_raw_key_type(type_spec.keys), T.untyped)
+          @value_type = T.let(type_spec.values, T.untyped)
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Hash[::String, T.untyped]) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Hash, got #{value.class}", path: path) unless value.is_a?(::Hash)
+
+          result = T.let({}, T::Hash[::String, T.untyped])
+          value.each do |key, item|
+            processor = @registry.processor_for(@value_type)
+            result[key.to_s] = processor.serialize(item, path: path.append(key.to_s))
+          end
+          result
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(T::Hash[T.untyped, T.untyped]) }
+        def deserialize(value, path: Path.new)
+          raise DeserializeError.new("Expected Hash, got #{value.class}", path: path) unless value.is_a?(::Hash)
+
+          result = T.let({}, T::Hash[T.untyped, T.untyped])
+          value.each do |key, item|
+            normalized_key = normalize_key(key)
+            processor = @registry.processor_for(@value_type)
+            result[normalized_key] = processor.deserialize(item, path: path.append(key.to_s))
+          end
+          result
+        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?(::Hash)
+
+          value.each do |key, val|
+            processor = @registry.processor_for(@value_type)
+            processor.traverse(val, path: path.append(key.to_s), &blk)
+          end
+        end
+
+        private
+
+        sig { params(key_type: T.untyped).returns(T.untyped) }
+        def extract_raw_key_type(key_type)
+          if key_type.is_a?(T::Types::Simple)
+            key_type.raw_type
+          else
+            key_type
+          end
+        end
+
+        sig { params(key: T.untyped).returns(T.untyped) }
+        def normalize_key(key)
+          if @key_type == ::String
+            key.to_s
+          elsif @key_type == ::Symbol
+            key.to_sym
+          else
+            key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module Serialization
+    module Processor
+      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, path: Path).returns(::Integer) }
+        def serialize(value, path: Path.new)
+          raise SerializeError.new("Expected Integer, got #{value.class}", path: path) unless value.is_a?(::Integer)
+
+          value
+        end
+
+        sig { override.params(value: T.untyped, path: Path).returns(::Integer) }
+        def deserialize(value, path: Path.new)
+          raise DeserializeError.new("Expected Integer, got #{value.class}", path: path) unless value.is_a?(::Integer)
+
+          value
+        end
+      end
+    end
+  end
+end