esquema 0.1.1 → 0.1.2

data/lib/esquema/schema_enhancer.rb

@@ -1,26 +1,12 @@
+# frozen_string_literal: true
+
 require "date"
 require "bigdecimal"
+require_relative "keyword_validator"
 
 module Esquema
+  # The SchemaEnhancer class is responsible for enhancing the schema of a model.
   class SchemaEnhancer
-    VALID_OPTIONS = %i[title description maxLength minLength pattern maxItems minItems uniqueItems
-                       maxProperties minProperties properties additionalProperties dependencies
-                       enum format multipleOf maximum exclusiveMaximum minimum exclusiveMinimum
-                       const allOf anyOf oneOf not default].freeze
-
-    TYPE_MAPPINGS = {
-      date: Date,
-      datetime: DateTime,
-      time: Time,
-      string: String,
-      text: String,
-      integer: Integer,
-      float: Float,
-      decimal: BigDecimal,
-      boolean: [TrueClass, FalseClass],
-      array: Array,
-      object: Object
-    }.freeze
     attr_reader :model
 
     def initialize(model, schema_enhancements)
@@ -28,38 +14,77 @@ module Esquema
       @model = model
     end
 
+    # Sets the description for the model.
+    #
+    # @param description [String] The description of the model.
     def model_description(description)
       @schema_enhancements[:model_description] = description
     end
 
+    # Sets the title for the model.
+    #
+    # @param title [String] The title of the model.
     def model_title(title)
       @schema_enhancements[:model_title] = title
     end
 
+    # Adds a property to the schema.
+    #
+    # @param name [Symbol] The name of the property.
+    # @param options [Hash] Additional options for the property.
     def property(name, options = {})
-      db_type = model.type_for_attribute(name).type
-      klass_type = Array(TYPE_MAPPINGS[db_type])
+      validate_property_as_attribute_for(name, options)
 
-      validate_default_value(options[:default], klass_type, db_type)
-      validate_enum_values(options[:enum], klass_type, db_type)
+      type = resolve_type(name, options)
+
+      KeywordValidator.validate!(name, type, options)
 
-      options.assert_valid_keys(VALID_OPTIONS)
       @schema_enhancements[:properties] ||= {}
       @schema_enhancements[:properties][name] = options
     end
 
-    private
+    # Adds a virtual property to the schema.
+    #
+    # @param name [Symbol] The name of the virtual property.
+    # @param options [Hash] Additional options for the virtual property.
+    def virtual_property(name, options = {})
+      options[:virtual] = true
+      property(name, options)
+    end
 
-    def validate_default_value(default_value, klass_type, db_type)
-      return unless default_value.present? && !klass_type.include?(default_value.class)
+    private
 
-      raise ArgumentError, "Default value must be of type #{db_type}"
+    # Resolves the type of a property.
+    #
+    # @param name [Symbol] The name of the property.
+    # @param options [Hash] Additional options for the property.
+    # @return [Symbol] The resolved type of the property.
+    def resolve_type(name, options = {})
+      if options[:virtual] == true
+        options[:type]
+      else
+        model.type_for_attribute(name).type
+      end
     end
 
-    def validate_enum_values(enum_values, klass_type, db_type)
-      return unless enum_values.present? && !enum_values.all? { |value| klass_type.include?(value.class) }
+    # Retrieves the valid properties for the model.
+    #
+    # @return [Array<Symbol>] The valid properties for the model.
+    def valid_properties
+      @valid_properties ||= begin
+        properties = model.column_names + model.reflect_on_all_associations.map(&:name)
+        properties.map(&:to_sym)
+      end
+    end
 
-      raise ArgumentError, "Enum values must be of type #{db_type}"
+    # Validates that a property is a valid attribute for the model.
+    #
+    # @param prop_name [Symbol] The name of the property.
+    # @param options [Hash] Additional options for the property.
+    # @raise [ArgumentError] If the property is not a valid attribute for the model.
+    def validate_property_as_attribute_for(prop_name, options = {})
+      return if options[:virtual] == true
+      raise ArgumentError, "`#{prop_name}` is not a model attribute." unless valid_properties.include?(prop_name.to_sym)
     end
   end
 end

data/lib/esquema/type_caster.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module Esquema
-  module TypeCaster
-    def self.cast(type, value) # rubocop:disable Metrics/MethodLength
+  module TypeCaster # rubocop:disable Style/Documentation
+    def self.cast(type, value) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       case type
       when :string, :text
         value.to_s
@@ -18,14 +18,26 @@ module Esquema
         rescue StandardError
           nil
         end
+      when :number
+        if value.to_s.include?(".")
+          begin
+            Float(value)
+          rescue StandardError
+            nil
+          end
+        else
+          begin
+            Integer(value)
+          rescue StandardError
+            nil
+          end
+        end
       when :boolean
         case value
         when true, "true", "1", 1
           true
         when false, "false", "0", 0
           false
-        else
-          nil # or handle as desired
         end
       when :array
         Array(value)

data/lib/esquema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Esquema
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/esquema/virtual_column.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Esquema
+  class VirtualColumn # rubocop:disable Style/Documentation
+    def initialize(property_name, options = {})
+      @property_name = property_name
+      @options = options
+    end
+
+    def name
+      @property_name.to_s
+    end
+
+    def class_name
+      @property_name.to_s.classify
+    end
+
+    def type
+      @options[:type]
+    end
+
+    def item_type
+      @options.dig(:items, :type)
+    end
+
+    def default
+      @options[:default]
+    end
+
+    def title
+      @options[:title]
+    end
+
+    def description
+      @options[:description]
+    end
+
+    def columns
+      []
+    end
+
+    def collection?
+      @options[:type] == :array
+    end
+  end
+end

data/lib/esquema.rb

@@ -3,6 +3,12 @@
 require_relative "esquema/version"
 require_relative "esquema/configuration"
 require_relative "esquema/model"
+require_relative "esquema/schema_enhancer"
+require_relative "esquema/keyword_validator"
+require_relative "esquema/builder"
+require_relative "esquema/property"
+require_relative "esquema/type_caster"
+require_relative "esquema/virtual_column"
 
-module Esquema
+module Esquema # rubocop:disable Style/Documentation
 end

data/lib/generators/esquema/install/install_generator.rb

@@ -4,6 +4,7 @@ require "rails/generators"
 
 module Esquema
   module Generators
+    # This generator is responsible for installing the Esquema gem.
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path("templates", __dir__)
 

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

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

data/sorbet/rbi/annotations/activemodel.rbi

@@ -0,0 +1,89 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveModel::Errors
+  Elem = type_member { { fixed: ActiveModel::Error } }
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def [](attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(ActiveModel::Error) }
+  def add(attribute, type = :invalid, **options); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Boolean) }
+  def added?(attribute, type = :invalid, options = {}); end
+
+  sig { params(options: T.untyped).returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json(options = nil); end
+
+  sig { returns(T::Array[Symbol]) }
+  def attribute_names; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T.nilable(T::Array[String])) }
+  def delete(attribute, type = nil, **options); end
+
+  sig { returns(T::Hash[Symbol, T::Array[T::Hash[Symbol, T.untyped]]]) }
+  def details; end
+
+  sig { returns(T::Array[Elem]) }
+  def errors; end
+
+  sig { params(attribute: T.any(Symbol, String), message: String).returns(String) }
+  def full_message(attribute, message); end
+
+  sig { returns(T::Array[String]) }
+  def full_messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def full_messages_for(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(String) }
+  def generate_message(attribute, type = :invalid, options = {}); end
+
+  sig { returns(T::Hash[Symbol, T::Array[ActiveModel::Error]]) }
+  def group_by_attribute; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def has_key?(attribute); end
+
+  sig { params(error: ActiveModel::Error, override_options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def import(error, override_options = {}); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def include?(attribute); end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Boolean) }
+  def key?(attribute); end
+
+  sig { params(other: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def merge!(other); end
+
+  sig { returns(T::Hash[Symbol, T::Array[String]]) }
+  def messages; end
+
+  sig { params(attribute: T.any(Symbol, String)).returns(T::Array[String]) }
+  def messages_for(attribute); end
+
+  sig { returns(T::Array[Elem]) }
+  def objects; end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped).returns(T::Boolean) }
+  def of_kind?(attribute, type = :invalid); end
+
+  sig { returns(T::Array[String]) }
+  def to_a; end
+
+  sig { params(full_messages: T.untyped).returns(T::Hash[Symbol, T::Array[String]]) }
+  def to_hash(full_messages = false); end
+
+  sig { params(attribute: T.any(Symbol, String), type: T.untyped, options: T.untyped).returns(T::Array[ActiveModel::Error]) }
+  def where(attribute, type = nil, **options); end
+end
+
+module ActiveModel::Validations
+  sig { returns(ActiveModel::Errors) }
+  def errors; end
+end

data/sorbet/rbi/annotations/activerecord.rbi

@@ -0,0 +1,92 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+class ActiveRecord::Schema
+  sig { params(info: T::Hash[T.untyped, T.untyped], blk: T.proc.bind(ActiveRecord::Schema).void).void }
+  def self.define(info = nil, &blk); end
+end
+
+class ActiveRecord::Migration
+  # @shim: Methods on migration are delegated to `SchemaStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::SchemaStatements
+
+  # @shim: Methods on migration are delegated to `DatabaseStatements` using `method_missing`
+  include ActiveRecord::ConnectionAdapters::DatabaseStatements
+end
+
+class ActiveRecord::Base
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  sig { returns(TrueClass) }
+  def present?; end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_initialize(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_find(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_touch(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_validation(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_save(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_create(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_update(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.before_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.around_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_destroy(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_commit(*args, **options, &block); end
+
+  sig { params(args: T.untyped, options: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).params(record: T.attached_class).void)).void }
+  def self.after_rollback(*args, **options, &block); end
+end
+
+class ActiveRecord::Relation
+  sig { returns(T::Boolean) }
+  def blank?; end
+end