skit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e8cc8c9595a7c97a181d67e3c183726e25dc6d5aea07510bcb09fd325ed6aae9
+  data.tar.gz: 8c6b40877f2949364e61015b761fc0d00376498917f28331f0d44f9154283685
+SHA512:
+  metadata.gz: 868a602fc15e934970fa4259eb6eccc19a91a0633ed7539671a490b7af0fa6e67ed4c78710acb6500c99cfbe64e28a347acc1fcd08bc23cc995d6ca58f24793c
+  data.tar.gz: 8cc83bc6d79f59ff448b0c113b53f100a8291a6f305c335976baaded471a1360cb877f6143ae99a4e6f63e9b2d55909f92f047c6d05703a8bc03d6d30bd206fc

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Speria, inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,469 @@
+# Skit
+
+A Ruby gem that integrates JSON Schema with Sorbet T::Struct. Generate type-safe Ruby code from JSON Schema, serialize/deserialize JSON data to T::Struct, and store complex objects in ActiveRecord JSON/JSONB columns.
+
+## Key Features
+
+- **JSON Schema to Code**: Generate Sorbet T::Struct definitions from JSON Schema
+- **Type-Safe Serialization**: Seamless conversion between T::Struct and JSON
+- **ActiveRecord Integration**: Store T::Struct in JSON/JSONB columns with full type safety
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "skit"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+## Usage
+
+### 1. Generate T::Struct from JSON Schema
+
+#### CLI Tool
+
+```bash
+# Basic usage
+skit generate schema.json
+
+# Specify class name
+skit generate -c User user_schema.json
+
+# Specify module name
+skit generate -m MyModule user_schema.json
+
+# Output to file
+skit generate -o lib/types/user.rb user_schema.json
+
+# Combine options
+skit generate -m MyApp::Types -c User -o user.rb user_schema.json
+```
+
+#### Programmatic API
+
+```ruby
+require "skit"
+
+schema = {
+  "type" => "object",
+  "properties" => {
+    "name" => { "type" => "string" },
+    "age" => { "type" => "integer" }
+  },
+  "required" => ["name"]
+}
+
+code = Skit::JsonSchema.generate(schema, class_name: "User", module_name: "MyApp")
+puts code
+```
+
+Output:
+
+```ruby
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module MyApp
+  class User < T::Struct
+    prop :name, String
+    prop :age, T.nilable(Integer)
+  end
+end
+```
+
+#### Enum Support
+
+JSON Schema `enum` generates `T::Enum` classes:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "status": {
+      "type": "string",
+      "enum": ["pending", "active", "completed"]
+    }
+  }
+}
+```
+
+Generates:
+
+```ruby
+class Status < T::Enum
+  enums do
+    Pending = new("pending")
+    Active = new("active")
+    Completed = new("completed")
+  end
+end
+
+class Root < T::Struct
+  prop :status, T.nilable(Status)
+end
+```
+
+#### Const Support
+
+JSON Schema `const` generates type-safe constant classes for discriminated unions:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "type": { "const": "dog" },
+    "breed": { "type": "string" }
+  }
+}
+```
+
+Generates:
+
+```ruby
+class TypeDog < Skit::JsonSchema::Types::Const
+  VALUE = "dog"
+end
+
+class Root < T::Struct
+  prop :type, T.nilable(TypeDog)
+  prop :breed, T.nilable(String)
+end
+```
+
+#### Discriminated Unions (oneOf with objects)
+
+JSON Schema `oneOf` with object types generates union types:
+
+```json
+{
+  "properties": {
+    "animal": {
+      "oneOf": [
+        { "type": "object", "properties": { "type": { "const": "dog" }, "breed": { "type": "string" } } },
+        { "type": "object", "properties": { "type": { "const": "cat" }, "color": { "type": "string" } } }
+      ]
+    }
+  }
+}
+```
+
+Generates:
+
+```ruby
+class AnimalVariant0 < T::Struct
+  prop :type, T.nilable(TypeDog)
+  prop :breed, T.nilable(String)
+end
+
+class AnimalVariant1 < T::Struct
+  prop :type, T.nilable(TypeCat)
+  prop :color, T.nilable(String)
+end
+
+class Root < T::Struct
+  prop :animal, T.any(AnimalVariant0, AnimalVariant1)
+end
+```
+
+### 2. Serialize/Deserialize T::Struct
+
+Use your own T::Struct definitions directly:
+
+```ruby
+class Product < T::Struct
+  const :name, String
+  const :price, Integer
+  const :tags, T::Array[String], default: []
+end
+
+# Deserialize: Hash -> T::Struct
+data = { "name" => "Ruby Book", "price" => 3000, "tags" => ["programming", "ruby"] }
+product = Skit.deserialize(data, Product)
+
+product.name  # => "Ruby Book"
+product.price # => 3000
+product.tags  # => ["programming", "ruby"]
+
+# Serialize: T::Struct -> Hash
+hash = Skit.serialize(product)
+# => {"name" => "Ruby Book", "price" => 3000, "tags" => ["programming", "ruby"]}
+```
+
+#### Union Types (T.any)
+
+Union types with T::Struct variants are automatically resolved during deserialization:
+
+```ruby
+class TypeDog < Skit::JsonSchema::Types::Const
+  VALUE = "dog"
+end
+
+class TypeCat < Skit::JsonSchema::Types::Const
+  VALUE = "cat"
+end
+
+class Dog < T::Struct
+  const :type, TypeDog
+  const :breed, String
+end
+
+class Cat < T::Struct
+  const :type, TypeCat
+  const :color, String
+end
+
+class Pet < T::Struct
+  const :animal, T.any(Dog, Cat)
+end
+
+# Deserialize: tries each variant, Const values discriminate the match
+data = { "animal" => { "type" => "dog", "breed" => "Shiba" } }
+pet = Skit.deserialize(data, Pet)
+pet.animal # => Dog instance
+
+# Serialize: detects the actual struct class
+hash = Skit.serialize(pet)
+# => {"animal" => {"type" => "dog", "breed" => "Shiba"}}
+```
+
+### 3. ActiveRecord JSONB Integration
+
+```ruby
+class Address < T::Struct
+  const :city, String
+  const :zip, T.nilable(String)
+end
+
+class Customer < ActiveRecord::Base
+  attribute :address, Skit::Attribute[Address]
+end
+
+# Assign with Hash
+customer = Customer.new
+customer.address = { city: "Tokyo", zip: "100-0001" }
+
+# Assign with T::Struct
+customer.address = Address.new(city: "Tokyo", zip: "100-0001")
+
+# Access as T::Struct
+customer.address.city  # => "Tokyo"
+customer.address.zip   # => "100-0001"
+
+# Save to database (stored as json)
+customer.save
+```
+
+### Array Type
+
+```ruby
+class Tag < T::Struct
+  const :name, String
+  const :color, String
+end
+
+class Article < ActiveRecord::Base
+  attribute :tags, Skit::Attribute[T::Array[Tag]]
+end
+
+article = Article.new
+article.tags = [
+  { name: "Ruby", color: "red" },
+  { name: "Rails", color: "red" }
+]
+
+article.tags[0].name  # => "Ruby"
+```
+
+### Hash Type
+
+```ruby
+class BoxSize < T::Struct
+  const :width, Integer
+  const :height, Integer
+end
+
+class Layout < ActiveRecord::Base
+  attribute :sizes, Skit::Attribute[T::Hash[String, BoxSize]]
+end
+
+layout = Layout.new
+layout.sizes = {
+  "small" => { width: 100, height: 50 },
+  "large" => { width: 200, height: 100 }
+}
+
+layout.sizes["small"].width  # => 100
+```
+
+### Nested Structs
+
+```ruby
+class Address < T::Struct
+  const :street, String
+  const :city, String
+end
+
+class Company < T::Struct
+  const :name, String
+  const :address, Address
+end
+
+class Employee < ActiveRecord::Base
+  attribute :company, Skit::Attribute[Company]
+end
+
+employee = Employee.new
+employee.company = {
+  name: "Acme Corp",
+  address: { street: "123 Main St", city: "Springfield" }
+}
+
+employee.company.address.city  # => "Springfield"
+```
+
+### Validation
+
+Skit integrates with ActiveModel::Validations:
+
+```ruby
+class Product < T::Struct
+  include ActiveModel::Validations
+
+  const :name, String
+  const :price, Integer
+
+  validates :name, presence: true
+  validates :price, numericality: { greater_than: 0 }
+end
+
+class Order < ActiveRecord::Base
+  attribute :product, Skit::Attribute[Product]
+  validates :product, skit: true
+end
+
+order = Order.new
+order.product = { name: "", price: -100 }
+order.valid?  # => false
+order.errors[:"product.name"]   # => ["can't be blank"]
+order.errors[:"product.price"]  # => ["must be greater than 0"]
+```
+
+Array elements are validated with indexed error keys:
+
+```ruby
+class Item < T::Struct
+  include ActiveModel::Validations
+
+  const :name, String
+  validates :name, presence: true
+end
+
+class Cart < ActiveRecord::Base
+  attribute :items, Skit::Attribute[T::Array[Item]]
+  validates :items, skit: true
+end
+
+cart = Cart.new
+cart.items = [{ name: "Book" }, { name: "" }]
+cart.valid?  # => false
+cart.errors[:"items.[1].name"]  # => ["can't be blank"]
+```
+
+## Type Mapping
+
+### JSON Schema to Sorbet
+
+| JSON Schema | Sorbet Type |
+|-------------|-------------|
+| `string` | `String` |
+| `string` (format: date) | `Date` |
+| `string` (format: date-time) | `Time` |
+| `string` (format: time) | `Time` |
+| `integer` | `Integer` |
+| `number` | `Float` |
+| `boolean` | `T::Boolean` |
+| `array` | `T::Array[ElementType]` |
+| `object` (with properties) | Custom T::Struct |
+| `object` (no properties) | `T::Hash[String, T.untyped]` |
+| `anyOf`/`oneOf` | `T.any(...)` or `T.nilable(...)` |
+| `anyOf`/`oneOf` (objects) | `T.any(Struct1, Struct2, ...)` |
+| `enum` | `T::Enum` |
+| `const` | `Skit::JsonSchema::Types::Const` subclass |
+
+### Sorbet to JSON (Serialization)
+
+| Sorbet Type | JSON Type |
+|-------------|-----------|
+| `String` | `string` |
+| `Integer`, `Float` | `number` |
+| `T::Boolean` | `boolean` |
+| `Symbol` | `string` |
+| `Date` | `string` (ISO 8601: `"2025-01-15"`) |
+| `Time` | `string` (ISO 8601: `"2025-01-15T10:30:00+09:00"`) |
+| `T::Struct` | `object` |
+| `T::Array[T]` | `array` |
+| `T::Hash[String, T]` | `object` |
+| `T.nilable(T)` | type or `null` |
+| `T.any(Struct1, Struct2)` | `object` (resolved by matching variant) |
+| `T::Enum` | serialized value (e.g. `"active"`) |
+| `Skit::JsonSchema::Types::Const` | constant value (e.g. `"dog"`) |
+
+## CLI Reference
+
+```bash
+skit generate [OPTIONS] SCHEMA_FILE
+
+Options:
+  -c, --class-name NAME    Root class name (default: from schema title or "GeneratedClass")
+  -m, --module-name NAME   Module name to wrap generated classes
+  -o, --output FILE        Output file path (default: stdout)
+  --typed LEVEL            Sorbet strictness level (default: "strict")
+  -h, --help               Show help message
+  -v, --version            Show version
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+### Running Tests
+
+```bash
+# Run all tests and linters (default task)
+bundle exec rake
+
+# Run tests only
+bundle exec rspec
+
+# Run unit tests only
+bundle exec rspec --tag type:unit
+
+# Run integration tests only
+bundle exec rspec --tag type:integration
+```
+
+### Code Quality
+
+```bash
+# Run RuboCop (linter)
+bundle exec rubocop
+bundle exec rubocop -a  # Auto-fix
+
+# Run Sorbet type checker
+bundle exec srb tc
+
+# Update RBI files (Tapioca)
+bundle exec rake sorbet:update
+```
+
+## License
+
+MIT License. See LICENSE file for details.

data/exe/skit

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "skit"
+
+if ARGV.empty? || ARGV[0] == "--help" || ARGV[0] == "-h"
+  puts "Usage: skit <command> [options]"
+  puts ""
+  puts "Commands:"
+  puts "  generate    Generate Sorbet T::Struct from JSON Schema"
+  puts ""
+  puts "Run 'skit <command> --help' for more information on a command."
+  exit 0
+end
+
+if ["--version", "-v"].include?(ARGV[0])
+  puts "skit #{Skit::VERSION}"
+  exit 0
+end
+
+command = ARGV.shift
+
+case command
+when "generate"
+  cli = Skit::JsonSchema::CLI.new
+  exit cli.run(ARGV)
+else
+  warn "Unknown command: #{command}"
+  warn "Run 'skit --help' for usage information."
+  exit 1
+end

data/lib/active_model/validations/skit_validator.rb

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ActiveModel
+  module Validations
+    class SkitValidator < ActiveModel::EachValidator
+      extend T::Sig
+
+      sig { params(record: T.untyped, attribute: T.any(String, Symbol), value: T.untyped).void }
+      def validate_each(record, attribute, value)
+        return if value.nil?
+
+        attribute_type = get_skit_attribute_type(record, attribute)
+        return unless attribute_type
+
+        processor = attribute_type.processor
+        processor.traverse(value) do |_type_spec, node, path|
+          next unless node.respond_to?(:valid?)
+          next if node.valid?
+
+          node.errors.each do |error|
+            error_key = build_error_key(attribute, path, error.attribute)
+            record.errors.add(error_key, error.message)
+          end
+        end
+      end
+
+      private
+
+      sig do
+        params(
+          attribute: T.any(::String, Symbol),
+          path: Skit::Serialization::Path,
+          error_attribute: Symbol
+        ).returns(::String)
+      end
+      def build_error_key(attribute, path, error_attribute)
+        if path.empty?
+          "#{attribute}.#{error_attribute}"
+        else
+          "#{attribute}.#{path}.#{error_attribute}"
+        end
+      end
+
+      sig { params(record: T.untyped, attribute: T.any(String, Symbol)).returns(T.nilable(Skit::Attribute)) }
+      def get_skit_attribute_type(record, attribute)
+        return nil unless record.class.respond_to?(:attribute_types)
+
+        attribute_type = record.class.attribute_types[attribute.to_s]
+        attribute_type.is_a?(Skit::Attribute) ? attribute_type : nil
+      end
+    end
+  end
+end

data/lib/skit/attribute.rb

@@ -0,0 +1,63 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "active_model"
+require "active_support/json"
+
+module Skit
+  class Attribute < ActiveModel::Type::Value
+    extend T::Sig
+
+    sig { params(type_spec: T.untyped).returns(Attribute) }
+    def self.[](type_spec)
+      new(type_spec)
+    end
+
+    sig { params(type_spec: T.untyped).void }
+    def initialize(type_spec)
+      super()
+      @type_spec = type_spec
+      @processor = T.let(
+        Serialization.default_registry.processor_for(type_spec),
+        Serialization::Processor::Base
+      )
+    end
+
+    sig { returns(Serialization::Processor::Base) }
+    attr_reader :processor
+
+    # Cast is called when assigning a value to the attribute
+    # e.g., record.data = { width: 100, height: 200 }
+    sig { params(value: T.untyped).returns(T.untyped) }
+    def cast(value)
+      return nil if value.nil?
+
+      @processor.deserialize(value)
+    end
+
+    # Serialize is called before saving to the database
+    # Returns JSON string for storage
+    sig { params(value: T.untyped).returns(T.nilable(String)) }
+    def serialize(value)
+      return nil if value.nil?
+
+      serialized = @processor.serialize(value)
+      ActiveSupport::JSON.encode(serialized)
+    end
+
+    # Deserialize is called when loading from the database
+    # Receives JSON string or Hash (depending on database adapter)
+    sig { params(value: T.untyped).returns(T.untyped) }
+    def deserialize(value)
+      return nil if value.nil?
+
+      data = if value.is_a?(String)
+               ActiveSupport::JSON.decode(value)
+             else
+               value
+             end
+
+      @processor.deserialize(data)
+    end
+  end
+end

data/lib/skit/json_schema/class_name_path.rb

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    class ClassNamePath
+      extend T::Sig
+
+      sig { params(parts: T::Array[String]).void }
+      def initialize(parts)
+        @parts = T.let(parts.dup, T::Array[String])
+      end
+
+      sig { params(title: String).returns(ClassNamePath) }
+      def self.title_to_class_name(title)
+        # Split existing PascalCase before conversion (APIResponseData -> API_Response_Data)
+        with_underscores = title.gsub(/([a-z])([A-Z])/, '\1_\2')
+                                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+
+        class_name = NamingUtils.to_pascal_case(with_underscores)
+
+        return default if class_name.empty?
+
+        ClassNamePath.new([class_name])
+      end
+
+      sig { params(file_path: T.nilable(String)).returns(ClassNamePath) }
+      def self.from_file_path(file_path)
+        return default unless file_path
+
+        basename = File.basename(file_path, ".*")
+        ClassNamePath.new([NamingUtils.to_pascal_case(basename)])
+      end
+
+      sig { returns(ClassNamePath) }
+      def self.default
+        ClassNamePath.new(["GeneratedClass"])
+      end
+
+      sig { returns(T::Array[String]) }
+      attr_reader :parts
+
+      sig { params(suffix: String).returns(ClassNamePath) }
+      def append(suffix)
+        ClassNamePath.new(@parts + [NamingUtils.to_pascal_case(suffix)])
+      end
+
+      sig { returns(T.nilable(String)) }
+      def parent_class
+        return nil if @parts.length < 2
+
+        @parts[0]
+      end
+
+      sig { returns(String) }
+      def property_name
+        T.must(@parts.last)
+      end
+
+      sig { returns(String) }
+      def to_class_name
+        # Generate class name by converting each part to PascalCase (TestUser + address -> TestUserAddress)
+        @parts.join
+      end
+    end
+  end
+end