sorbet-schema 0.1.0

data/lib/typed/field.rb

@@ -0,0 +1,28 @@
+# typed: strict
+
+module Typed
+  class Field < T::Struct
+    extend T::Sig
+
+    include ActsAsComparable
+
+    const :name, Symbol
+    const :type, T::Class[T.anything]
+    const :required, T::Boolean, default: true
+
+    sig { returns(T::Boolean) }
+    def required?
+      required
+    end
+
+    sig { returns(T::Boolean) }
+    def optional?
+      !required
+    end
+
+    sig { params(value: Value).returns(Validations::ValidationResult) }
+    def validate(value)
+      Validations::FieldTypeValidator.new.validate(field: self, value: value)
+    end
+  end
+end

data/lib/typed/hash_serializer.rb

@@ -0,0 +1,21 @@
+# typed: strict
+
+module Typed
+  class HashSerializer < Serializer
+    InputHash = T.type_alias { T::Hash[T.any(Symbol, String), T.untyped] }
+    OutputHash = T.type_alias { Params }
+
+    Input = type_member { {fixed: InputHash} }
+    Output = type_member { {fixed: OutputHash} }
+
+    sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
+    def deserialize(source)
+      deserialize_from_creation_params(HashTransformer.new.deep_symbolize_keys(source))
+    end
+
+    sig { override.params(struct: T::Struct).returns(Output) }
+    def serialize(struct)
+      HashTransformer.new.deep_symbolize_keys(struct.serialize)
+    end
+  end
+end

data/lib/typed/json_serializer.rb

@@ -0,0 +1,28 @@
+# typed: strict
+
+require "json"
+
+module Typed
+  class JSONSerializer < Serializer
+    Input = type_member { {fixed: String} }
+    Output = type_member { {fixed: String} }
+
+    sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
+    def deserialize(source)
+      parsed_json = JSON.parse(source)
+
+      creation_params = schema.fields.each_with_object(T.let({}, Params)) do |field, hsh|
+        hsh[field.name] = parsed_json[field.name.to_s]
+      end
+
+      deserialize_from_creation_params(creation_params)
+    rescue JSON::ParserError
+      Failure.new(ParseError.new(format: :json))
+    end
+
+    sig { override.params(struct: T::Struct).returns(Output) }
+    def serialize(struct)
+      JSON.generate(struct.serialize)
+    end
+  end
+end

data/lib/typed/parse_error.rb

@@ -0,0 +1,12 @@
+# typed: strict
+
+module Typed
+  class ParseError < DeserializeError
+    extend T::Sig
+
+    sig { params(format: Symbol).void }
+    def initialize(format:)
+      super("#{format} could not be parsed. Check for typos.")
+    end
+  end
+end

data/lib/typed/schema.rb

@@ -0,0 +1,10 @@
+# typed: strict
+
+module Typed
+  class Schema < T::Struct
+    include ActsAsComparable
+
+    const :fields, T::Array[Field], default: []
+    const :target, T.class_of(T::Struct)
+  end
+end

data/lib/typed/serializer.rb

@@ -0,0 +1,61 @@
+# typed: strict
+
+module Typed
+  class Serializer
+    extend T::Sig
+    extend T::Helpers
+    extend T::Generic
+    abstract!
+
+    Input = type_member
+    Output = type_member
+    Params = T.type_alias { T::Hash[Symbol, T.untyped] }
+    DeserializeResult = T.type_alias { Typed::Result[T::Struct, DeserializeError] }
+
+    sig { returns(Schema) }
+    attr_reader :schema
+
+    sig { params(schema: Schema).void }
+    def initialize(schema:)
+      @schema = schema
+    end
+
+    sig { abstract.params(source: Output).returns(DeserializeResult) }
+    def deserialize(source)
+    end
+
+    sig { abstract.params(struct: T::Struct).returns(Output) }
+    def serialize(struct)
+    end
+
+    private
+
+    sig { params(creation_params: Params).returns(DeserializeResult) }
+    def deserialize_from_creation_params(creation_params)
+      results = schema.fields.map do |field|
+        value = creation_params[field.name]
+
+        if value.nil?
+          field.validate(value)
+        elsif value.class != field.type
+          coercion_result = Coercion.coerce(field: field, value: value)
+
+          if coercion_result.success?
+            field.validate(coercion_result.payload)
+          else
+            Failure.new(Validations::ValidationError.new(coercion_result.error.message))
+          end
+        else
+          field.validate(value)
+        end
+      end
+
+      Validations::ValidationResults
+        .new(results: results)
+        .combine
+        .and_then do |validated_params|
+          Success.new(schema.target.new(**validated_params))
+        end
+    end
+  end
+end

data/lib/typed/validations/field_type_validator.rb

@@ -0,0 +1,24 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class FieldTypeValidator
+      extend T::Sig
+
+      include FieldValidator
+
+      sig { override.params(field: Field, value: Value).returns(ValidationResult) }
+      def validate(field:, value:)
+        if field.type == value.class
+          Success.new(ValidatedValue.new(name: field.name, value: value))
+        elsif field.required? && value.nil?
+          Failure.new(RequiredFieldError.new(field_name: field.name))
+        elsif field.optional? && value.nil?
+          Success.new(ValidatedValue.new(name: field.name, value: value))
+        else
+          Failure.new(TypeMismatchError.new(field_name: field.name, field_type: field.type, given_type: value.class))
+        end
+      end
+    end
+  end
+end

data/lib/typed/validations/field_validator.rb

@@ -0,0 +1,15 @@
+# typed: strict
+
+module Typed
+  module Validations
+    module FieldValidator
+      extend T::Sig
+      extend T::Helpers
+      interface!
+
+      sig { abstract.params(field: Field, value: Value).returns(ValidationResult) }
+      def validate(field:, value:)
+      end
+    end
+  end
+end

data/lib/typed/validations/multiple_validation_error.rb

@@ -0,0 +1,16 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class MultipleValidationError < ValidationError
+      extend T::Sig
+
+      sig { params(errors: T::Array[ValidationError]).void }
+      def initialize(errors:)
+        combined_message = errors.map(&:message).join(" | ")
+
+        super("Multiple validation errors found: #{combined_message}")
+      end
+    end
+  end
+end

data/lib/typed/validations/required_field_error.rb

@@ -0,0 +1,14 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class RequiredFieldError < ValidationError
+      extend T::Sig
+
+      sig { params(field_name: Symbol).void }
+      def initialize(field_name:)
+        super("#{field_name} is required.")
+      end
+    end
+  end
+end

data/lib/typed/validations/type_mismatch_error.rb

@@ -0,0 +1,14 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class TypeMismatchError < ValidationError
+      extend T::Sig
+
+      sig { params(field_name: Symbol, field_type: T::Class[T.anything], given_type: T::Class[T.anything]).void }
+      def initialize(field_name:, field_type:, given_type:)
+        super("Invalid type given to #{field_name}. Expected #{field_type}, got #{given_type}.")
+      end
+    end
+  end
+end

data/lib/typed/validations/validated_value.rb

@@ -0,0 +1,12 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class ValidatedValue < T::Struct
+      include ActsAsComparable
+
+      const :name, Symbol
+      const :value, Value
+    end
+  end
+end

data/lib/typed/validations/validation_error.rb

@@ -0,0 +1,8 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class ValidationError < DeserializeError
+    end
+  end
+end

data/lib/typed/validations/validation_results.rb

@@ -0,0 +1,29 @@
+# typed: strict
+
+module Typed
+  module Validations
+    class ValidationResults < T::Struct
+      extend T::Sig
+
+      const :results, T::Array[ValidationResult]
+
+      sig { returns(Result[ValidatedParams, ValidationError]) }
+      def combine
+        failing_results = results.select(&:failure?)
+
+        case failing_results.length
+        when 0
+          Success.new(
+            results.each_with_object({}) do |result, validated_params|
+              validated_params[result.payload.name] = result.payload.value
+            end
+          )
+        when 1
+          Failure.new(T.must(failing_results.first).error)
+        else
+          Failure.new(MultipleValidationError.new(errors: failing_results.map(&:error)))
+        end
+      end
+    end
+  end
+end

data/lib/typed/validations.rb

@@ -0,0 +1,8 @@
+# typed: strict
+
+module Typed
+  module Validations
+    ValidationResult = T.type_alias { Result[ValidatedValue, ValidationError] }
+    ValidatedParams = T.type_alias { T::Hash[Symbol, Value] }
+  end
+end

data/sorbet/config

@@ -0,0 +1,5 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/
+--ignore=test/test_data/

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true