easy_talk 0.1.0

data/lib/easy_talk/builders/number_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for number properties.
+    class NumberBuilder < BaseBuilder
+      VALID_OPTIONS = {
+        multiple_of: { type: T.any(Integer, Float), key: :multipleOf },
+        minimum: { type: T.any(Integer, Float), key: :minimum },
+        maximum: { type: T.any(Integer, Float), key: :maximum },
+        exclusive_minimum: { type: T.any(Integer, Float), key: :exclusiveMinimum },
+        exclusive_maximum: { type: T.any(Integer, Float), key: :exclusiveMaximum },
+        enum: { type: T::Array[T.any(Integer, Float)], key: :enum },
+        const: { type: T.any(Integer, Float), key: :const },
+        default: { type: T.any(Integer, Float), key: :default }
+      }.freeze
+
+      # Initializes a new instance of the NumberBuilder class.
+      sig { params(name: Symbol, _type: T.untyped, constraints: Hash).void }
+      def initialize(name, _type = nil, constraints = {})
+        super(name, { type: 'number' }, constraints, VALID_OPTIONS)
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/object_builder.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module Builders
+    # Builder class for json schema objects.
+    class ObjectBuilder < BaseBuilder
+      extend T::Sig
+
+      attr_reader :klass, :schema
+
+      VALID_OPTIONS = {
+        properties: { type: T::Hash[Symbol, T.untyped], key: :properties },
+        additional_properties: { type: T::Boolean, key: :additionalProperties },
+        subschemas: { type: T::Array[T.untyped], key: :subschemas },
+        required: { type: T::Array[Symbol], key: :required },
+        defs: { type: T.untyped, key: :$defs },
+        allOf: { type: T.untyped, key: :allOf },
+        anyOf: { type: T.untyped, key: :anyOf },
+        oneOf: { type: T.untyped, key: :oneOf },
+        not: { type: T.untyped, key: :not }
+      }.freeze
+
+      sig { params(schema_definition: EasyTalk::SchemaDefinition).void }
+      def initialize(schema_definition)
+        @schema_definition = schema_definition
+        @schema = schema_definition.schema.dup
+        @required_properties = []
+        name = schema_definition.name ? schema_definition.name.to_sym : :klass
+        super(name, { type: 'object' }, options, VALID_OPTIONS)
+      end
+
+      private
+
+      def properties_from_schema_definition(properties)
+        properties.each_with_object({}) do |(property_name, options), context|
+          @required_properties << property_name unless options[:type].respond_to?(:nilable?) && options[:type].nilable?
+          context[property_name] = Property.new(property_name, options[:type], options[:constraints])
+        end
+      end
+
+      def subschemas_from_schema_definition(subschemas)
+        subschemas.each do |subschema|
+          definitions = subschema.items.each_with_object({}) do |item, hash|
+            hash[item.name] = item.schema
+          end
+          schema[:defs] = definitions
+          references = subschema.items.map do |item|
+            { '$ref': item.ref_template }
+          end
+          schema[subschema.name] = references
+        end
+      end
+
+      def options
+        subschemas_from_schema_definition(subschemas)
+        @options = schema
+        @options[:properties] = properties_from_schema_definition(properties)
+        @options[:required] = @required_properties
+        @options.reject! { |_key, value| [nil, [], {}].include?(value) }
+        @options
+      end
+
+      def properties
+        schema.delete(:properties) || {}
+      end
+
+      def subschemas
+        schema.delete(:subschemas) || []
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/one_of_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'composition_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for integer properties.
+    class OneOfBuilder < CompositionBuilder
+    end
+  end
+end

data/lib/easy_talk/builders/ref_array_builder.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for array properties.
+    class RefArrayBuilder < BaseBuilder
+      # Initializes a new instance of the ArrayBuilder class.
+      sig { params(name: Symbol).void }
+      def initialize(name)
+        super(name, { type: 'array' }, options, {})
+      end
+
+      private
+
+      sig { void }
+      # Updates the option types for the array builder.
+      def update_option_types
+        VALID_OPTIONS[:enum][:type] = T::Array[@inner_type]
+        VALID_OPTIONS[:const][:type] = T::Array[@inner_type]
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/string_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+require 'sorbet-runtime' # Add the import statement for the T module
+
+module EasyTalk
+  module Builders
+    # Builder class for string properties.
+    class StringBuilder < BaseBuilder
+      extend T::Sig
+      VALID_OPTIONS = {
+        format: { type: String, key: :format },
+        pattern: { type: String, key: :pattern },
+        min_length: { type: Integer, key: :minLength },
+        max_length: { type: Integer, key: :maxLength },
+        enum: { type: T::Array[String], key: :enum },
+        const: { type: String, key: :const },
+        default: { type: String, key: :default }
+      }.freeze
+
+      sig { params(name: Symbol, _type: T.untyped, constraints: Hash).void }
+      def initialize(name, _type = nil, constraints = {})
+        super(name, { type: 'string' }, constraints, VALID_OPTIONS)
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/time_builder.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # Builder class for time properties.
+    class TimeBuilder < StringBuilder
+      def schema
+        super.tap do |schema|
+          schema[:format] = 'time'
+        end
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/typed_array_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module Builders
+    # Builder class for array properties.
+    class TypedArrayBuilder < BaseBuilder
+      VALID_OPTIONS = {
+        min_items: { type: Integer, key: :minItems },
+        max_items: { type: Integer, key: :maxItems },
+        unique_items: { type: T::Boolean, key: :uniqueItems },
+        enum: { type: T::Array[T.untyped], key: :enum },
+        const: { type: T::Array[T.untyped], key: :const }
+      }.freeze
+
+      attr_reader :type
+
+      sig { params(name: Symbol, type: T.untyped, constraints: Hash).void }
+      def initialize(name, type, constraints = {})
+        @name = name
+        @type = type
+        update_option_types
+        super(name, { type: 'array' }, constraints, VALID_OPTIONS)
+      end
+
+      private
+
+      # Modifies the schema to include the `items` property.
+      #
+      # @return [Hash] The built schema.
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def schema
+        super.tap do |schema|
+          schema[:items] = Property.new(@name, inner_type, {}).build
+        end
+      end
+
+      def inner_type
+        return unless type.is_a?(T::Types::TypedArray)
+
+        type.type.raw_type
+      end
+
+      sig { void }
+      # Updates the option types for the array builder.
+      def update_option_types
+        VALID_OPTIONS[:enum][:type] = T::Array[inner_type]
+        VALID_OPTIONS[:const][:type] = T::Array[inner_type]
+      end
+    end
+  end
+end

data/lib/easy_talk/builders/union_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'base_builder'
+
+module EasyTalk
+  module Builders
+    # Base builder class for array-type properties.
+    class UnionBuilder
+      extend T::Sig
+      sig { params(name: Symbol, type: T.untyped, constraints: T.untyped).void }
+      def initialize(name, type, constraints)
+        @name = name
+        @type = type
+        @constraints = constraints
+        @context = {}
+      end
+
+      def build
+        @context[@name] = {
+          'anyOf' => schemas
+        }
+      end
+
+      def schemas
+        types.map do |type|
+          Property.new(@name, type, @constraints).build
+        end
+      end
+
+      def types
+        @type.types
+      end
+    end
+  end
+end

data/lib/easy_talk/keywords.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  KEYWORDS = %i[
+    description
+    type
+    title
+    property
+    required
+    items
+    additional_items
+    pattern_properties
+    additional_properties
+    dependencies
+    dependent_required
+    format
+    content_media_type
+    content_encoding
+    enum
+    const
+    default
+    examples
+    max_length
+    min_length
+    pattern
+    maximum
+    exclusive_maximum
+    minimum
+    exclusive_minimum
+    multiple_of
+    max_items
+    min_items
+    unique_items
+    max_properties
+    min_properties
+  ].freeze
+end

data/lib/easy_talk/model.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/time'
+require 'active_support/concern'
+require 'active_support/json'
+require_relative 'builder'
+require_relative 'schema_definition'
+
+module EasyTalk
+  # The Model module can be included in a class to add JSON schema definition and generation support.
+  module Model
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      base.singleton_class.instance_eval do
+        define_method(:inherited) do |subclass|
+          super(subclass)
+          subclass.extend(SubclassExtension)
+        end
+      end
+    end
+
+    # This module provides extension methods for subclasses with schema definitions.
+    module SubclassExtension
+      # Returns true if the class inherits a schema.
+      def inherits_schema?
+        true
+      end
+
+      # Returns the superclass that the class inherits from.
+      def inherits_from
+        superclass
+      end
+    end
+
+    # Module containing class-level methods for defining and accessing the schema of a model.
+    #
+    # This module provides methods for defining and accessing the JSON schema of a model.
+    # It includes methods for defining the schema, retrieving the schema definition,
+    # and generating the JSON schema for the model.
+    #
+    # Example usage:
+    #
+    #   class MyModel
+    #     extend ClassMethods
+    #
+    #     define_schema do
+    #       # schema definition goes here
+    #     end
+    #   end
+    #
+    #   MyModel.json_schema #=> returns the JSON schema for MyModel
+    #
+    #   MyModel.schema_definition #=> returns the unvalidated schema definition for MyModel
+    #
+    #   MyModel.ref_template #=> returns the reference template for MyModel
+    #
+    #   MyModel.inherits_schema? #=> returns false
+    #
+    #   MyModel.schema #=> returns the validated schema for MyModel
+    #
+    #   MyModel.schema_definition #=> returns the unvalidated schema definition for MyModel
+    #
+    #   MyModel.json_schema #=> returns the JSON schema for MyModel
+    #
+    # @see SchemaDefinition
+    # @see Builder
+    module ClassMethods
+      def schema
+        @schema ||= Builder.new(schema_definition).schema
+      end
+
+      def inherits_schema?
+        false
+      end
+
+      def ref_template
+        "#/$defs/#{name}"
+      end
+
+      # Returns the JSON schema for the model.
+      def json_schema
+        @json_schema ||= begin
+          schema = Builder.new(schema_definition).schema
+          schema.to_json
+        end
+      end
+
+      # Define the schema using the provided block.
+      def define_schema(&block)
+        raise ArgumentError, 'The class must have a name' unless name.present?
+
+        @schema_definition = SchemaDefinition.new(name)
+        @schema_definition.instance_eval(&block)
+      end
+
+      def schema_definition
+        @schema_definition ||= {}
+      end
+    end
+  end
+end

data/lib/easy_talk/property.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'builders/integer_builder'
+require_relative 'builders/number_builder'
+require_relative 'builders/boolean_builder'
+require_relative 'builders/null_builder'
+require_relative 'builders/string_builder'
+require_relative 'builders/date_builder'
+require_relative 'builders/datetime_builder'
+require_relative 'builders/time_builder'
+require_relative 'builders/any_of_builder'
+require_relative 'builders/all_of_builder'
+require_relative 'builders/one_of_builder'
+require_relative 'builders/typed_array_builder'
+require_relative 'builders/union_builder'
+
+# frozen_string_literal: true
+
+module EasyTalk
+  # Property class for building a JSON schema property.
+  class Property
+    extend T::Sig
+    attr_reader :name, :type, :constraints
+
+    TYPE_TO_BUILDER = {
+      'String' => Builders::StringBuilder,
+      'Integer' => Builders::IntegerBuilder,
+      'Float' => Builders::NumberBuilder,
+      'BigDecimal' => Builders::NumberBuilder,
+      'T::Boolean' => Builders::BooleanBuilder,
+      'NilClass' => Builders::NullBuilder,
+      'Date' => Builders::DateBuilder,
+      'DateTime' => Builders::DatetimeBuilder,
+      'Time' => Builders::TimeBuilder,
+      'anyOf' => Builders::AnyOfBuilder,
+      'allOf' => Builders::AllOfBuilder,
+      'oneOf' => Builders::OneOfBuilder,
+      'T::Types::TypedArray' => Builders::TypedArrayBuilder,
+      'T::Types::Union' => Builders::UnionBuilder
+    }.freeze
+
+    # Initializes a new instance of the Property class.
+    # @param name [Symbol] The name of the property.
+    # @param type [Object] The type of the property.
+    # @param constraints [Hash] The property constraints.
+    # @raise [ArgumentError] If the property type is missing.
+    sig do
+      params(name: Symbol, type: T.any(String, Object),
+             constraints: T::Hash[Symbol, T.untyped]).void
+    end
+    def initialize(name, type = nil, constraints = {})
+      @name = name
+      @type = type
+      @constraints = constraints
+      raise ArgumentError, 'property type is missing' if type.blank?
+    end
+
+    def build
+      if type.is_a?(T::Types::Simple)
+        @type = type.raw_type
+        return self
+      end
+
+      if builder
+        builder.new(name, type, constraints).build
+      else
+        type.respond_to?(:schema) ? type.schema : 'object'
+      end
+    end
+
+    def as_json(*_args)
+      build.as_json
+    end
+
+    def builder
+      TYPE_TO_BUILDER[type.class.name.to_s] || TYPE_TO_BUILDER[type.name.to_s]
+    end
+  end
+end

data/lib/easy_talk/schema_definition.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'pry-byebug'
+require_relative 'keywords'
+
+module EasyTalk
+  #
+  #= EasyTalk \SchemaDefinition
+  # SchemaDefinition provides the methods for defining a schema within the define_schema block.
+  # The @schema is a hash that contains the unvalidated schema definition for the model.
+  # A SchemaDefinition instanace is the passed to the Builder.build_schema method to validate and compile the schema.
+  class SchemaDefinition
+    extend T::Sig
+    extend T::AnyOf
+    extend T::OneOf
+    extend T::AllOf
+
+    attr_reader :name, :schema
+
+    def initialize(name)
+      @schema = {}
+      @name = name
+    end
+
+    EasyTalk::KEYWORDS.each do |keyword|
+      define_method(keyword) do |*values|
+        @schema[keyword] = values.size > 1 ? values : values.first
+      end
+    end
+
+    def compose(*subschemas)
+      @schema[:subschemas] ||= []
+      @schema[:subschemas] += subschemas
+    end
+
+    sig { params(name: Symbol, type: T.untyped, constraints: T.untyped).void }
+    def property(name, type, **constraints)
+      @schema[:properties] ||= {}
+      @schema[:properties][name] = { type:, constraints: }
+    end
+  end
+end

data/lib/easy_talk/sorbet_extension.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# This module provides additional functionality for working with Sorbet types.
+module SorbetExtension
+  # Checks if the types in the collection include the NilClass type.
+  #
+  # @return [Boolean] true if the types include NilClass, false otherwise.
+  def nilable?
+    types.any? do |type|
+      type.respond_to?(:raw_type) && type.raw_type == NilClass
+    end
+  end
+end
+
+T::Types::Union.include SorbetExtension

data/lib/easy_talk/types/all_of.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'base_composer'
+# The EasyTalk module provides a collection of types for composing schemas.
+module EasyTalk
+  # The `Types` module provides a collection of classes for composing different types.
+  module Types
+    # Represents a composition type that allows all of the specified types.
+    class AllOf < BaseComposer
+      def self.name
+        :allOf
+      end
+
+      def name
+        :allOf
+      end
+    end
+  end
+end
+
+module T
+  # no-doc
+  module AllOf
+    # Creates a new instance of `EasyTalk::Types::AllOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the `EasyTalk::Types::AllOf` constructor
+    # @return [EasyTalk::Types::AllOf] a new instance of `EasyTalk::Types::AllOf`
+    def self.[](*args)
+      EasyTalk::Types::AllOf.new(*args)
+    end
+  end
+end

data/lib/easy_talk/types/any_of.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'base_composer'
+module EasyTalk
+  module Types
+    # The `Types` module provides a collection of composers for defining different types.
+    #
+    # This module contains composers for various types such as `AnyOf`, `AllOf`, etc.
+    # Each composer is responsible for defining the behavior and properties of its respective type.
+    class AnyOf < BaseComposer
+      # Returns the name of the AnyOf composer.
+      #
+      # @return [Symbol] The name of the composer.
+      def self.name
+        :anyOf
+      end
+
+      # Returns the name of the AnyOf composer.
+      #
+      # @return [Symbol] The name of the composer.
+      def name
+        :anyOf
+      end
+    end
+  end
+end
+
+module T
+  # no-doc
+  module AnyOf
+    # Creates a new instance of `EasyTalk::Types::AnyOf` with the given arguments.
+    #
+    # @param args [Array] the list of arguments to be passed to the `EasyTalk::Types::AnyOf` constructor
+    # @return [EasyTalk::Types::AnyOf] a new instance of `EasyTalk::Types::AnyOf`
+    def self.[](*args)
+      EasyTalk::Types::AnyOf.new(*args)
+    end
+  end
+end

data/lib/easy_talk/types/base_composer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  module Types
+    # no-doc
+    class BaseComposer
+      extend T::Sig
+      extend T::Generic
+
+      Elem = type_member
+
+      sig { returns(T::Array[Elem]) }
+      attr_reader :items
+
+      # Initializes a new instance of the BaseComposer class.
+      #
+      # @param args [Array] the items to be assigned to the instance variable @items
+      def initialize(*args)
+        @items = args
+      end
+    end
+  end
+end

data/lib/easy_talk/types/one_of.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'base_composer'
+module EasyTalk
+  module Types
+    # Represents a composition type that allows one of the specified types.
+    class OneOf < BaseComposer
+      # Returns the name of the composition type.
+      def self.name
+        :oneOf
+      end
+
+      # Returns the name of the composition type.
+      def name
+        :oneOf
+      end
+    end
+  end
+end
+
+module T
+  # Creates a new instance of `EasyTalk::Types::OneOf` with the given arguments.
+  #
+  # @param args [Array] the list of arguments to be passed to the `EasyTalk::Types::OneOf` constructor
+  # @return [EasyTalk::Types::OneOf] a new instance of `EasyTalk::Types::OneOf`
+  module OneOf
+    def self.[](*args)
+      EasyTalk::Types::OneOf.new(*args)
+    end
+  end
+end

data/lib/easy_talk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EasyTalk
+  VERSION = '0.1.0'
+end