skit 0.1.0

data/lib/skit/json_schema/cli.rb

@@ -0,0 +1,166 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+module Skit
+  module JsonSchema
+    class CLI
+      extend T::Sig
+
+      sig { params(args: T::Array[String]).returns(Integer) }
+      def run(args)
+        options = parse_options(args)
+
+        # Exit normally when help or version is requested
+        return 0 if options[:help_requested] || options[:version_requested]
+
+        return 1 unless valid_args?(args)
+
+        schema_file = T.must(args.first)
+        return 1 unless valid_schema_file?(schema_file)
+
+        process_schema(schema_file, options)
+      end
+
+      private
+
+      sig { params(args: T::Array[String]).returns(T::Hash[Symbol, T.untyped]) }
+      def parse_options(args)
+        options = {
+          class_name: nil,
+          module_name: nil,
+          output_file: nil,
+          typed_strictness: "strict",
+          help_requested: T.let(false, T::Boolean),
+          version_requested: T.let(false, T::Boolean)
+        }
+
+        parser = OptionParser.new
+        setup_option_parser(parser, options)
+
+        begin
+          parser.parse!(args)
+        rescue OptionParser::ParseError => e
+          warn "Error: #{e.message}"
+          warn parser.help
+          options[:help_requested] = true
+        end
+
+        options
+      end
+
+      sig { params(args: T::Array[String]).returns(T::Boolean) }
+      def valid_args?(args)
+        return true unless args.empty?
+
+        warn "Error: Please provide a JSON Schema file"
+        warn "Use --help for usage information"
+        false
+      end
+
+      sig { params(schema_file: String).returns(T::Boolean) }
+      def valid_schema_file?(schema_file)
+        return true if File.exist?(schema_file)
+
+        warn "Error: File '#{schema_file}' not found"
+        false
+      end
+
+      sig { params(schema_file: String, options: T::Hash[Symbol, T.untyped]).returns(Integer) }
+      def process_schema(schema_file, options)
+        schema_content = File.read(schema_file)
+        schema = JSON.parse(schema_content)
+
+        config = Config.new(
+          class_name: T.cast(options[:class_name], T.nilable(String)),
+          module_name: T.cast(options[:module_name], T.nilable(String)),
+          typed_strictness: T.cast(options[:typed_strictness], String)
+        )
+        analyzer = SchemaAnalyzer.new(T.cast(schema, T::Hash[String, T.untyped]), config)
+        module_definition = analyzer.analyze
+
+        generator = CodeGenerator.new(module_definition, config)
+        ruby_code = generator.generate
+
+        output_result(ruby_code, options)
+        0
+      rescue JSON::ParserError => e
+        warn "Error: Invalid JSON in '#{schema_file}': #{e.message}"
+        1
+      rescue Skit::Error => e
+        warn "Error: #{e.message}"
+        1
+      rescue StandardError => e
+        warn "Unexpected error: #{e.message}"
+        trace = e.backtrace&.join("\n")
+        warn trace if trace
+        1
+      end
+
+      sig { params(ruby_code: String, options: T::Hash[Symbol, T.untyped]).void }
+      def output_result(ruby_code, options)
+        output_file = T.cast(options[:output_file], T.nilable(String))
+        if output_file
+          File.write(output_file, ruby_code)
+          warn "Generated T::Struct written to #{output_file}"
+        else
+          puts ruby_code
+        end
+      end
+
+      sig { params(parser: OptionParser, options: T::Hash[Symbol, T.untyped]).void }
+      def setup_option_parser(parser, options)
+        parser.banner = "Usage: skit generate [options] <schema_file>"
+        parser.separator ""
+        parser.separator "Generate Sorbet T::Struct definitions from JSON Schema"
+        parser.separator ""
+        parser.separator "Options:"
+
+        setup_options(parser, options)
+        setup_examples(parser)
+      end
+
+      sig { params(parser: OptionParser, options: T::Hash[Symbol, T.untyped]).void }
+      def setup_options(parser, options)
+        parser.on("-c", "--class-name NAME", "Specify the class name for the generated struct") do |name|
+          options[:class_name] = name
+        end
+
+        parser.on("-m", "--module-name NAME", "Specify the module name to wrap the generated struct") do |name|
+          options[:module_name] = name
+        end
+
+        parser.on("-o", "--output FILE", "Write output to specified file instead of stdout") do |file|
+          options[:output_file] = file
+        end
+
+        parser.on("-t", "--typed LEVEL", Config::VALID_TYPED_LEVELS, "Sorbet typed strictness level",
+                  "(#{Config::VALID_TYPED_LEVELS.join(", ")})") do |level|
+          options[:typed_strictness] = level
+        end
+
+        parser.on("-h", "--help", "Show this help message") do
+          puts parser
+          options[:help_requested] = true
+        end
+
+        parser.on("-v", "--version", "Show version") do
+          puts "skit #{Skit::VERSION}"
+          options[:version_requested] = true
+        end
+      end
+
+      sig { params(opts: OptionParser).void }
+      def setup_examples(opts)
+        opts.separator ""
+        opts.separator "Examples:"
+        opts.separator "  skit generate user.json"
+        opts.separator "  skit generate -c User -o user.rb user_schema.json"
+        opts.separator "  skit generate -m MyModule -c User user_schema.json"
+        opts.separator "  skit generate -m Foo::Bar -c Baz user_schema.json"
+      end
+    end
+  end
+end

data/lib/skit/json_schema/code_generator.rb

@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    class CodeGenerator
+      extend T::Sig
+
+      sig { params(module_definition: Definitions::Module, config: Config).void }
+      def initialize(module_definition, config)
+        @module_definition = module_definition
+        @config = config
+      end
+
+      sig { returns(String) }
+      def generate
+        parts = []
+
+        # Header
+        parts << "# typed: #{@config.typed_strictness}"
+        parts << "# frozen_string_literal: true"
+        parts << ""
+        parts << "# This file is autogenerated by skit"
+        parts << "# DO NOT EDIT MANUALLY"
+        parts << ""
+        parts << 'require "sorbet-runtime"'
+        parts << 'require "skit"' if const_types?
+
+        module_parts = @config.module_name&.split("::")
+        indent_level = module_parts&.length || 0
+
+        if module_parts
+          parts << ""
+          module_parts.each_with_index do |module_part, index|
+            parts << "#{"  " * index}module #{module_part}"
+          end
+        end
+
+        # Enum types
+        @module_definition.enum_types.each do |enum_type|
+          parts << ""
+          parts << generate_enum_class(enum_type, indent_level)
+        end
+
+        # Const types
+        @module_definition.const_types.each do |const_type|
+          parts << ""
+          parts << generate_const_class(const_type, indent_level)
+        end
+
+        # Nested structs
+        @module_definition.nested_structs.each do |nested_struct|
+          parts << ""
+          parts << generate_single_struct(nested_struct, indent_level)
+        end
+
+        # Main struct
+        parts << ""
+        parts << generate_single_struct(@module_definition.root_struct, indent_level)
+
+        module_parts&.reverse&.each_with_index do |_, index|
+          parts << "#{"  " * (T.must(module_parts).length - index - 1)}end"
+        end
+
+        parts.join("\n")
+      end
+
+      private
+
+      sig { returns(T::Boolean) }
+      def const_types?
+        !@module_definition.const_types.empty?
+      end
+
+      sig { params(enum_type: Definitions::EnumType, indent_level: Integer).returns(String) }
+      def generate_enum_class(enum_type, indent_level = 0)
+        lines = []
+        base_indent = "  " * indent_level
+
+        lines << "#{base_indent}class #{enum_type.class_name} < T::Enum"
+        lines << "#{base_indent}  enums do"
+
+        enum_type.values.each do |value| # rubocop:disable Style/HashEachMethods
+          member_name = Definitions::EnumType.value_to_member_name(value)
+          value_literal = Definitions::EnumType.value_literal(value)
+          lines << "#{base_indent}    #{member_name} = new(#{value_literal})"
+        end
+
+        lines << "#{base_indent}  end"
+        lines << "#{base_indent}end"
+
+        lines.join("\n")
+      end
+
+      sig { params(const_type: Definitions::ConstType, indent_level: Integer).returns(String) }
+      def generate_const_class(const_type, indent_level = 0)
+        lines = []
+        base_indent = "  " * indent_level
+
+        lines << "#{base_indent}class #{const_type.class_name} < Skit::JsonSchema::Types::Const"
+        lines << "#{base_indent}  VALUE = #{const_type.value_literal}"
+        lines << "#{base_indent}end"
+
+        lines.join("\n")
+      end
+
+      sig { params(struct_def: Definitions::Struct, indent_level: Integer).returns(String) }
+      def generate_single_struct(struct_def, indent_level = 0)
+        lines = []
+        base_indent = "  " * indent_level
+
+        # Description comment
+        lines << "#{base_indent}# #{struct_def.description}" if struct_def.description
+
+        # Class definition
+        lines << "#{base_indent}class #{struct_def.class_name} < T::Struct"
+
+        # Properties
+        struct_def.properties.each do |property|
+          property.comment&.split("\n")&.each do |comment_line|
+            lines << "#{base_indent}  # #{comment_line}"
+          end
+          lines << "#{base_indent}  #{property.mutability} :#{property.name}, #{property.type.to_sorbet_type}"
+        end
+
+        lines << "#{base_indent}end"
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/skit/json_schema/config.rb

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    class Config
+      extend T::Sig
+
+      VALID_TYPED_LEVELS = T.let(%w[ignore false true strict strong].freeze, T::Array[String])
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :class_name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :module_name
+
+      sig { returns(String) }
+      attr_reader :typed_strictness
+
+      sig { params(class_name: T.nilable(String), module_name: T.nilable(String), typed_strictness: String).void }
+      def initialize(class_name: nil, module_name: nil, typed_strictness: "strict")
+        @class_name = T.let(validate_class_name(class_name), T.nilable(String))
+        @module_name = T.let(validate_module_name(module_name), T.nilable(String))
+        @typed_strictness = T.let(validate_typed_strictness(typed_strictness), String)
+      end
+
+      private
+
+      sig { params(class_name: T.nilable(String)).returns(T.nilable(String)) }
+      def validate_class_name(class_name)
+        return nil if class_name.nil?
+
+        unless class_name.match?(/\A[A-Z][a-zA-Z0-9_]*\z/)
+          raise ArgumentError,
+                "Invalid class name: #{class_name.inspect}. Must start with uppercase letter " \
+                "and contain only alphanumeric characters and underscores."
+        end
+
+        class_name
+      end
+
+      sig { params(module_name: T.nilable(String)).returns(T.nilable(String)) }
+      def validate_module_name(module_name)
+        return nil if module_name.nil?
+
+        # Support Foo::Bar::Baz format
+        unless module_name.match?(/\A[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*\z/)
+          raise ArgumentError,
+                "Invalid module name: #{module_name.inspect}. Must be valid Ruby module name " \
+                "(e.g., 'MyModule' or 'Foo::Bar::Baz')."
+        end
+
+        module_name
+      end
+
+      sig { params(level: String).returns(String) }
+      def validate_typed_strictness(level)
+        unless VALID_TYPED_LEVELS.include?(level)
+          raise ArgumentError,
+                "Invalid typed strictness level: #{level}. Valid options are: #{VALID_TYPED_LEVELS.join(", ")}"
+        end
+
+        level
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      # Represents a JSON Schema const value type.
+      #
+      # This generates a Skit::JsonSchema::Types::Const subclass
+      # that matches a specific constant value.
+      class ConstType
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :class_name
+
+        sig { returns(T.untyped) }
+        attr_reader :value
+
+        sig { returns(T::Boolean) }
+        attr_reader :nullable
+
+        sig do
+          params(
+            class_name: String,
+            value: T.untyped,
+            nullable: T::Boolean
+          ).void
+        end
+        def initialize(class_name:, value:, nullable: false)
+          @class_name = class_name
+          @value = value
+          @nullable = nullable
+        end
+
+        sig { returns(String) }
+        def to_sorbet_type
+          nullable ? "T.nilable(#{@class_name})" : @class_name
+        end
+
+        sig { returns(ConstType) }
+        def with_nullable
+          ConstType.new(class_name: @class_name, value: @value, nullable: true)
+        end
+
+        # Returns the Ruby literal representation of the value
+        # rubocop:disable Lint/DuplicateBranch -- Sorbet requires exhaustive case for proper return type
+        sig { returns(String) }
+        def value_literal
+          case @value
+          when String
+            @value.inspect
+          when Integer, Float
+            @value.to_s
+          when TrueClass
+            "true"
+          when FalseClass
+            "false"
+          else
+            # This branch should never be reached due to validation in SchemaAnalyzer
+            @value.inspect
+          end
+        end
+        # rubocop:enable Lint/DuplicateBranch
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      # Represents a T::Enum type for code generation
+      class EnumType
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :class_name
+
+        sig { returns(T::Array[T.any(String, Integer, Float)]) }
+        attr_reader :values
+
+        sig { returns(T::Boolean) }
+        attr_reader :nullable
+
+        sig do
+          params(
+            class_name: String,
+            values: T::Array[T.any(String, Integer, Float)],
+            nullable: T::Boolean
+          ).void
+        end
+        def initialize(class_name:, values:, nullable: false)
+          @class_name = class_name
+          @values = values
+          @nullable = nullable
+        end
+
+        sig { returns(String) }
+        def to_sorbet_type
+          nullable ? "T.nilable(#{@class_name})" : @class_name
+        end
+
+        sig { returns(EnumType) }
+        def with_nullable
+          EnumType.new(class_name: @class_name, values: @values, nullable: true)
+        end
+
+        # Generate enum member name from value
+        sig { params(value: T.any(String, Integer, Float)).returns(String) }
+        def self.value_to_member_name(value)
+          case value
+          when String
+            result = NamingUtils.to_pascal_case(value)
+            return "Empty" if result.empty?
+
+            result = "Val#{result}" if result.match?(/\A\d/)
+            result
+          when Integer, Float
+            NamingUtils.number_to_name(value)
+          end
+        end
+
+        # Generate value literal for code generation
+        sig { params(value: T.any(String, Integer, Float)).returns(String) }
+        def self.value_literal(value)
+          case value
+          when String
+            value.inspect
+          when Integer, Float
+            value.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      class HashPropertyType
+        extend T::Sig
+
+        sig { returns(PropertyTypes) }
+        attr_reader :value_type
+
+        sig { returns(T::Boolean) }
+        attr_reader :nullable
+
+        sig { params(value_type: PropertyTypes, nullable: T::Boolean).void }
+        def initialize(value_type:, nullable: false)
+          @value_type = value_type
+          @nullable = nullable
+        end
+
+        sig { returns(String) }
+        def to_sorbet_type
+          value_type_str = @value_type.to_sorbet_type
+          hash_type = "T::Hash[String, #{value_type_str}]"
+          nullable ? "T.nilable(#{hash_type})" : hash_type
+        end
+
+        sig { returns(HashPropertyType) }
+        def with_nullable
+          HashPropertyType.new(value_type: @value_type, nullable: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      class Module
+        extend T::Sig
+
+        sig { returns(Struct) }
+        attr_reader :root_struct
+
+        sig { returns(T::Array[Struct]) }
+        attr_reader :nested_structs
+
+        sig { returns(T::Array[ConstType]) }
+        attr_reader :const_types
+
+        sig { returns(T::Array[EnumType]) }
+        attr_reader :enum_types
+
+        sig do
+          params(
+            root_struct: Struct,
+            nested_structs: T::Array[Struct],
+            const_types: T::Array[ConstType],
+            enum_types: T::Array[EnumType]
+          ).void
+        end
+        def initialize(root_struct:, nested_structs: [], const_types: [], enum_types: [])
+          @root_struct = root_struct
+          @nested_structs = nested_structs
+          @const_types = const_types
+          @enum_types = enum_types
+        end
+
+        sig { returns(T::Boolean) }
+        def const_types?
+          !@const_types.empty?
+        end
+
+        sig { returns(T::Boolean) }
+        def enum_types?
+          !@enum_types.empty?
+        end
+
+        sig { returns(T::Boolean) }
+        def nested_structs?
+          !@nested_structs.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      class PropertyType
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :base_type
+
+        sig { returns(T::Boolean) }
+        attr_reader :nullable
+
+        sig do
+          params(
+            base_type: String,
+            nullable: T::Boolean
+          ).void
+        end
+        def initialize(base_type:, nullable: false)
+          @base_type = base_type
+          @nullable = nullable
+        end
+
+        sig { returns(String) }
+        def to_sorbet_type
+          nullable ? "T.nilable(#{@base_type})" : @base_type
+        end
+
+        sig { returns(PropertyType) }
+        def with_nullable
+          PropertyType.new(base_type: @base_type, nullable: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Skit
+  module JsonSchema
+    module Definitions
+      # Type alias: Union type of PropertyType-related classes
+      PropertyTypes = T.type_alias do
+        T.any(PropertyType, ArrayPropertyType, HashPropertyType, UnionPropertyType, ConstType, EnumType)
+      end
+    end
+  end
+end