rails-param-validation 0.1.0

data/lib/rails-param-validation/types/types.rb

@@ -0,0 +1,100 @@
+module RailsParamValidation
+
+module AnnotationTypes
+class AnnotationT
+  attr_reader :inner_type
+
+  def initialize(inner_type)
+    @inner_type = inner_type
+  end
+end
+
+class ArrayT < AnnotationT
+  def initialize(inner_type)
+    super(inner_type)
+  end
+end
+
+class HashT < AnnotationT
+  attr_reader :key_type
+
+  def initialize(inner_type, key_type = String)
+    super(inner_type)
+
+    @key_type = key_type
+  end
+end
+
+class OptionalT < AnnotationT
+  attr_reader :default
+
+  def initialize(inner_type, default)
+    super(inner_type)
+
+    @default = default
+  end
+end
+
+class CustomT < AnnotationT
+  attr_reader :type
+
+  def initialize(type)
+    @type = type
+  end
+
+  def schema
+    CustomT.registry[@type]
+  end
+
+  def self.register(type, schema)
+    registry[type] = schema
+  end
+
+  def self.registered(type)
+    raise TypeNotFound.new(type) unless registry.key? type
+    registry[type]
+  end
+
+  def self.types
+    registry.keys
+  end
+
+  private
+
+  def self.registry
+    @@types ||= {}
+  end
+end
+end
+
+module Types
+  def ArrayType(inner_type)
+    AnnotationTypes::ArrayT.new(inner_type)
+  end
+
+  def HashType(inner_type, key_type = String)
+    AnnotationTypes::HashT.new(inner_type, key_type)
+  end
+
+  def Optional(inner_type, default)
+    AnnotationTypes::OptionalT.new(inner_type, default)
+  end
+
+  def Type(type)
+    AnnotationTypes::CustomT.new(type)
+  end
+end
+
+end
+
+begin
+  class Boolean; end unless Module.const_get("Boolean").is_a?(Class)
+rescue NameError
+  class Boolean; end
+end
+
+begin
+  class Uuid; end unless Module.const_get("Uuid").is_a?(Class)
+rescue NameError
+  class Uuid; end
+end

data/lib/rails-param-validation/validator.rb

@@ -0,0 +1,51 @@
+module RailsParamValidation
+
+  class MatchResult
+    attr_reader :errors, :matching, :value
+
+    def initialize(value, path = nil, error = nil)
+      @value = value
+      @errors = []
+
+      unless error.nil?
+        @errors.push(path: path, message: error)
+      end
+
+      @matching = error.nil?
+    end
+
+    def matches?
+      @matching
+    end
+
+    # @param [MatchResult] other
+    # @return [MatchResult]
+    def merge!(other)
+      @matching = @matching && other.matching
+      @errors += other.errors
+
+      self
+    end
+
+    def error_messages
+      @errors.map { |e| { path: e[:path].join('/'), message: e[:message] } }
+    end
+  end
+
+  class Validator
+    attr_reader :schema
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    # @return [MatchData]
+    def matches?(path, structure)
+    end
+
+    def to_openapi
+      raise NotImplementedError
+    end
+  end
+
+end

data/lib/rails-param-validation/validator_factory.rb

@@ -0,0 +1,37 @@
+require_relative "./errors/no_matching_factory"
+require_relative "./validator"
+
+module RailsParamValidation
+
+  class ValidatorFactory
+
+    # @param [ValidatorFactory] factory
+    def self.register(factory)
+      factories.push factory
+    end
+
+    # @return [Array<ValidatorFactory>]
+    def self.factories
+      @@factories ||= []
+    end
+
+    # @return [Validator]
+    def self.create(schema)
+      factory = factories.detect { |f| f.supports? schema }
+
+      if factory.nil?
+        raise NoMatchingFactory.new(schema)
+      end
+
+      factory.create schema
+    end
+
+    # @return [Boolean]
+    def supports?(schema)
+    end
+
+    # @return Validator
+    def create(schema)
+    end
+  end
+end

data/lib/rails-param-validation/validators/alternatives.rb

@@ -0,0 +1,42 @@
+module RailsParamValidation
+
+class AlternativesValidator < Validator
+    # @param [Array] schema
+    def initialize(schema)
+      super schema
+
+      @inner_validators = schema.map { |value| ValidatorFactory.create(value) }
+    end
+
+    def matches?(path, data)
+      result = MatchResult.new nil, path, "The value did not match any of the alternatives"
+
+      @inner_validators.each_with_index do |validator, idx|
+        match = validator.matches?(path + ["[#{idx}]"], data)
+
+        if match.matches?
+          return match
+        else
+          result.merge! match
+        end
+      end
+
+      result
+    end
+
+    def to_openapi
+      { oneOf: @inner_validators.map(&:to_openapi) }
+    end
+  end
+
+  class AlternativesValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema.is_a? Array
+    end
+
+    def create(schema)
+      AlternativesValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/array.rb

@@ -0,0 +1,49 @@
+module RailsParamValidation
+
+  class ArrayValidator < Validator
+    # @param [ArrayT] schema
+    def initialize(schema)
+      super schema
+
+      @inner_validator = ValidatorFactory.create schema.inner_type
+    end
+
+    def matches?(path, data)
+      # Don't proceed if it is not an array at all
+      unless data.is_a? Array
+        return MatchResult.new nil, path, "Expected an array"
+      end
+
+      value = []
+      result = MatchResult.new nil
+
+      # Verify each entry
+      data.each_with_index do |entry, index|
+        match = @inner_validator.matches?(path + [index.to_s], entry)
+
+        if match.matches?
+          value.push match.value
+        else
+          result.merge! match
+        end
+      end
+
+      result.matches? ? MatchResult.new(value) : result
+    end
+
+    def to_openapi
+      { type: :array, items: @inner_validator.to_openapi }
+    end
+  end
+
+  class ArrayValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema.is_a? AnnotationTypes::ArrayT
+    end
+
+    def create(schema)
+      ArrayValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/boolean.rb

@@ -0,0 +1,38 @@
+module RailsParamValidation
+
+  class BooleanValidator < Validator
+    def initialize(schema)
+      super schema
+    end
+
+    def matches?(path, data)
+      if data.is_a?(TrueClass) || data.is_a?(FalseClass)
+        return MatchResult.new data
+      end
+
+      case data
+      when "true"
+        return MatchResult.new true
+      when "false"
+        return MatchResult.new false
+      else
+        return MatchResult.new(nil, path, "Expected a boolean (true, false)")
+      end
+    end
+
+    def to_openapi
+      { type: :boolean }
+    end
+  end
+
+  class BooleanValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema == Boolean
+    end
+
+    def create(schema)
+      BooleanValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/constant.rb

@@ -0,0 +1,38 @@
+module RailsParamValidation
+
+  class ConstantValidator < Validator
+    def initialize(schema)
+      super schema
+
+      @constant = schema
+    end
+
+    def matches?(path, data)
+
+      if data.to_s == @constant.to_s
+        if @constant.is_a?(String)
+          MatchResult.new @constant.clone
+        else
+          MatchResult.new @constant
+        end
+      else
+        MatchResult.new nil, path, "Expected value #{@constant.to_s}"
+      end
+    end
+
+    def to_openapi
+      ValidatorFactory.create(schema.class).to_openapi.merge(enum: [schema])
+    end
+  end
+
+  class ConstantValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      ![String, Symbol, Numeric, TrueClass, FalseClass].detect { |klass| schema.is_a? klass }.nil?
+    end
+
+    def create(schema)
+      ConstantValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/custom_type.rb

@@ -0,0 +1,28 @@
+module RailsParamValidation
+
+  class CustomTypeValidator < Validator
+    def initialize(type)
+      super type
+      @validator = ValidatorFactory.create type.schema
+    end
+
+    def matches?(path, data)
+      @validator.matches? path, data
+    end
+
+    def to_openapi
+      { '$ref': "#/components/schemas/#{schema.type}" }
+    end
+  end
+
+  class CustomTypeValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema.is_a? AnnotationTypes::CustomT
+    end
+
+    def create(schema)
+      CustomTypeValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/date.rb

@@ -0,0 +1,39 @@
+module RailsParamValidation
+
+  class DateValidator < Validator
+    def initialize(schema)
+      super schema
+    end
+
+    def matches?(path, data)
+      if data.is_a?(DateTime)
+        MatchResult.new data.to_date
+      elsif data.is_a?(Time)
+        MatchResult.new data.to_date
+      elsif data.is_a?(String)
+        begin
+          MatchResult.new(data.to_date || raise(ArgumentError))
+        rescue ArgumentError
+          MatchResult.new nil, path, "Expected a date"
+        end
+      else
+        MatchResult.new nil, path, "Expected a date"
+      end
+    end
+
+    def to_openapi
+      { type: :string, format: 'date' }
+    end
+  end
+
+  class DateValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema == Date
+    end
+
+    def create(schema)
+      DateValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/datetime.rb

@@ -0,0 +1,39 @@
+module RailsParamValidation
+
+  class DateTimeValidator < Validator
+    def initialize(schema)
+      super schema
+    end
+
+    def matches?(path, data)
+      if data.is_a?(DateTime)
+        MatchResult.new data
+      elsif data.is_a?(Time)
+        MatchResult.new data.to_datetime
+      elsif data.is_a?(String)
+        begin
+          MatchResult.new(data.to_datetime || raise(ArgumentError))
+        rescue ArgumentError
+          MatchResult.new nil, path, "Expected a date-time"
+        end
+      else
+        MatchResult.new nil, path, "Expected a date-time"
+      end
+    end
+
+    def to_openapi
+      { type: :string, format: 'date-time' }
+    end
+  end
+
+  class DateTimeValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema == DateTime
+    end
+
+    def create(schema)
+      DateTimeValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/float.rb

@@ -0,0 +1,39 @@
+module RailsParamValidation
+
+  class FloatValidator < Validator
+    def initialize(schema)
+      super schema
+    end
+
+    def matches?(path, data)
+      if data.is_a? Numeric
+        return MatchResult.new data.to_f
+      end
+
+      unless data.is_a? String
+        return MatchResult.new(nil, path, "Expected a float")
+      end
+
+      begin
+        return MatchResult.new(Float(data))
+      rescue ArgumentError
+        return MatchResult.new(nil, path, "Expected a float")
+      end
+    end
+
+    def to_openapi
+      { type: :number, format: :double }
+    end
+  end
+
+  class FloatValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema == Float
+    end
+
+    def create(schema)
+      FloatValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/hash.rb

@@ -0,0 +1,52 @@
+module RailsParamValidation
+
+  class HashValidator < Validator
+    # @param [HashT] schema
+    def initialize(schema)
+      super schema
+
+      @value_validator = ValidatorFactory.create schema.inner_type
+      @key_validator = ValidatorFactory.create schema.key_type
+    end
+
+    def matches?(path, data)
+      # Don't proceed if it is not an array at all
+      unless data.is_a? Hash
+        return MatchResult.new nil, path, "Expected a hash"
+      end
+
+      value = {}
+      result = MatchResult.new nil
+
+      # Verify each entry
+      data.each do |key, entry|
+        match_key = @value_validator.matches?(path + ["#{key}[key]"], key)
+        match_value = @value_validator.matches?(path + [key], entry)
+
+        if match_value.matches? && match_key.matches?
+          value[match_key.value] = match_value.value
+        else
+          result.merge! match_key unless match_key.matches?
+          result.merge! match_value unless match_value.matches?
+        end
+      end
+
+      result.matches? ? MatchResult.new(value) : result
+    end
+
+    def to_openapi
+      { type: :object, additionalProperties: @value_validator.to_openapi }
+    end
+  end
+
+  class HashValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema.is_a? AnnotationTypes::HashT
+    end
+
+    def create(schema)
+      HashValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/integer.rb

@@ -0,0 +1,39 @@
+module RailsParamValidation
+
+  class IntegerValidator < Validator
+    def initialize(schema)
+      super schema
+    end
+
+    def matches?(path, data)
+      if data.is_a? Integer
+        return MatchResult.new data
+      end
+
+      unless data.is_a? String
+        return MatchResult.new(nil, path, "Expected an integer")
+      end
+
+      begin
+        return MatchResult.new(Integer(data))
+      rescue ArgumentError
+        return MatchResult.new(nil, path, "Expected an integer")
+      end
+    end
+
+    def to_openapi
+      { type: :integer }
+    end
+  end
+
+  class IntegerValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema == Integer
+    end
+
+    def create(schema)
+      IntegerValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/object.rb

@@ -0,0 +1,63 @@
+module RailsParamValidation
+
+  class ObjectValidator < Validator
+    # @param [Hash] schema
+    def initialize(schema)
+      super schema
+
+      @inner_validators = schema.map { |key, value| [key, ValidatorFactory.create(value)] }.to_h
+    end
+
+    def matches?(path, data)
+      # Don't proceed if it is not hash at all
+      unless data.is_a? Hash
+        return MatchResult.new nil, path, "Expected an object"
+      end
+
+      value = {}
+      result = MatchResult.new nil
+
+      # Verify each entry
+      @inner_validators.each do |property, validator|
+        match = validator.matches?(path + [property], data.key?(property.to_s) ? data[property.to_s] : data[property.to_sym])
+
+        if match.matches?
+          value[property] = match.value
+        else
+          result.merge! match
+        end
+      end
+
+      additional_properties = data.keys.reject { |k| @inner_validators.key?(k.to_s) || @inner_validators.key?(k.to_sym) }
+      additional_properties.each do |property|
+        result.merge! MatchResult.new(nil, path + [property], "Unknown property")
+      end
+
+      result.matches? ? MatchResult.new(value) : result
+    end
+
+    def to_openapi
+      openapi = { type: :object, properties: {} }
+      required = []
+      schema.each do |key, _|
+        validator = @inner_validators[key]
+        openapi[:properties][key] = validator.to_openapi
+        required.push key unless validator.is_a? OptionalValidator
+      end
+
+      openapi[:required] = required if required.any?
+      openapi
+    end
+  end
+
+  class ObjectValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema.is_a? Hash
+    end
+
+    def create(schema)
+      ObjectValidator.new schema
+    end
+  end
+
+end

data/lib/rails-param-validation/validators/optional.rb

@@ -0,0 +1,44 @@
+module RailsParamValidation
+
+  class OptionalValidator < Validator
+    def initialize(schema)
+      super schema
+
+      @inner_validator = ValidatorFactory.create schema.inner_type
+      @default         = schema.default
+    end
+
+    def matches?(path, data)
+      if data.nil?
+        if @default.is_a? Proc
+          MatchResult.new @default.call
+        else
+          MatchResult.new @default
+        end
+      else
+        @inner_validator.matches? path, data
+      end
+    end
+
+    def to_openapi
+      child = @inner_validator.to_openapi
+      child[:nullable] = true
+      if child.key? :enum
+        child[:enum].push nil
+      end
+
+      child
+    end
+  end
+
+  class OptionalValidatorFactory < ValidatorFactory
+    def supports?(schema)
+      schema.is_a? AnnotationTypes::OptionalT
+    end
+
+    def create(schema)
+      OptionalValidator.new schema
+    end
+  end
+
+end