explicit 0.2.1 → 0.2.2

data/lib/explicit/type/big_decimal.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Explicit::Type::BigDecimal < Explicit::Type
+  attr_reader :min, :max
+
+  def initialize(min: nil, max: nil)
+    @min = min
+    @max = max
+  end
+
+  def validate(value)
+    unless value.is_a?(::String) || value.is_a?(::Integer)
+      return [:error, error_i18n("bigdecimal")]
+    end
+
+    decimalvalue = BigDecimal(value)
+
+    if min && decimalvalue < min
+      return [:error, error_i18n("min", min:)]
+    end
+
+    if max && decimalvalue > max
+      return [:error, error_i18n("max", max:)]
+    end
+
+    [:ok, decimalvalue]
+  rescue ArgumentError
+    return [:error, error_i18n("bigdecimal")]
+  end
+
+  concerning :Webpage do
+    def summary
+      "string"
+    end
+
+    def partial
+      "explicit/documentation/type/big_decimal"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "string",
+        pattern: /^\d*\.?\d*$/.inspect,
+        format: "decimal number",
+        description: swagger_description([
+          min&.then { swagger_i18n("big_decimal_min", min: _1) },
+          max&.then { swagger_i18n("big_decimal_max", max: _1) }
+        ])
+      }
+    end
+  end
+end

data/lib/explicit/type/boolean.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Explicit::Type::Boolean < Explicit::Type
+  VALUES = {
+    true => true,
+    "true" => true,
+    "on" => true,
+    "1" => true,
+    1 => true,
+    false => false,
+    "false" => false,
+    "off" => false,
+    "0" => false,
+    0 => false
+  }.freeze
+
+  def validate(value)
+    value = VALUES[value]
+
+    return [:error, error_i18n("boolean")] if value.nil?
+
+    [:ok, value]
+  end
+
+  concerning :Webpage do
+    def summary
+      "boolean"
+    end
+
+    def partial
+      "explicit/documentation/type/boolean"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "boolean",
+        description: swagger_description([])
+      }
+    end
+  end
+end

data/lib/explicit/type/date_time_iso8601.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "time"
+
+class Explicit::Type::DateTimeISO8601 < Explicit::Type
+  def validate(value)
+    return [:error, error_i18n("date_time_iso8601")] if !value.is_a?(::String)
+
+    timeval = Time.iso8601(value)
+
+    [:ok, timeval]
+  rescue ArgumentError
+    [:error, error_i18n("date_time_iso8601")]
+  end
+
+  concerning :Webpage do
+    def summary
+      "string"
+    end
+
+    def partial
+      "explicit/documentation/type/date_time_iso8601"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "string",
+        format: "date-time",
+        description: swagger_description([
+          swagger_i18n("date_time_iso8601")
+        ])
+      }
+    end
+  end
+end

data/lib/explicit/type/date_time_posix.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "time"
+
+class Explicit::Type::DateTimePosix < Explicit::Type
+  def validate(value)
+    if !value.is_a?(::Integer) && !value.is_a?(::String)
+      return [:error, error_i18n("date_time_posix")]
+    end
+
+    datetimeval = DateTime.strptime(value.to_s, "%s")
+
+    [:ok, datetimeval]
+  rescue Date::Error
+    return [:error, error_i18n("date_time_posix")]
+  end
+
+  concerning :Webpage do
+    def summary
+      "integer"
+    end
+
+    def partial
+      "explicit/documentation/type/date_time_posix"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "integer",
+        minimum: 1,
+        format: "POSIX time",
+        description: swagger_description([
+          swagger_i18n("date_time_posix")
+        ])
+      }
+    end
+  end
+end

data/lib/explicit/type/enum.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Explicit::Type::Enum < Explicit::Type
+  attr_reader :allowed_values
+
+  def initialize(allowed_values)
+    @allowed_values = allowed_values
+  end
+
+  def validate(value)
+    if allowed_values.include?(value)
+      [:ok, value]
+    else
+      [:error, error_i18n("enum", allowed_values: allowed_values.inspect)]
+    end
+  end
+
+  concerning :Webpage do
+    def summary
+      "string"
+    end
+
+    def partial
+      "explicit/documentation/type/enum"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "string",
+        enum: allowed_values,
+        description: swagger_description([])
+      }
+    end
+  end
+end

data/lib/explicit/type/file.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Explicit::Type::File < Explicit::Type
+  include ActionView::Helpers::NumberHelper
+
+  attr_reader :max_size, :content_types
+
+  FILE_CLASSES = [
+    ActionDispatch::Http::UploadedFile,
+    Rack::Test::UploadedFile
+  ].freeze
+
+  def initialize(max_size: nil, content_types: nil)
+    @max_size = max_size
+    @content_types = Array(content_types)
+  end
+
+  def validate(value)
+    if !FILE_CLASSES.any? { |klass| value.is_a?(klass) }
+      return [:error, error_i18n("file")] 
+    end
+
+    if max_size && value.size > max_size
+      return [:error, error_i18n("file_max_size", max_size: number_to_human_size(max_size))]
+    end
+
+    if content_types.any? && !content_types.include?(value.content_type)
+      return [:error, error_i18n("file_content_type", allowed_content_types: content_types.inspect)]
+    end
+
+    [:ok, value]
+  end
+
+  concerning :Webpage do
+    def summary
+      "file"
+    end
+
+    def partial
+      "explicit/documentation/type/file"
+    end
+
+    def has_details?
+      max_size.present? || content_types.any?
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "string",
+        format: "binary",
+        description: swagger_description([
+          max_size&.then { swagger_i18n("file_max_size", max_size: number_to_human_size(_1)) },
+          content_types.any? ? swagger_i18n("file_content_types", content_types: content_types.join(', ')) : nil
+        ])
+      }
+    end
+  end
+end

data/lib/explicit/type/hash.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class Explicit::Type::Hash < Explicit::Type
+  attr_reader :keytype, :valuetype, :empty
+
+  def initialize(keytype:, valuetype:, empty: true)
+    @keytype = Explicit::Type.build(keytype)
+    @valuetype = Explicit::Type.build(valuetype)
+    @empty = empty
+  end
+
+  def validate(value)
+    return [:error, error_i18n("hash")] if !value.respond_to?(:[])
+    return [:error, error_i18n("empty")] if value.empty? && empty == false
+
+    validated_hash = {}
+
+    value.each do |key, value|
+      case [keytype.validate(key), valuetype.validate(value)]
+      in [[:ok, validated_key], [:ok, validated_value]]
+        validated_hash[validated_key] = validated_value
+      in [[:error, error], _]
+        return [:error, error_i18n("hash_key", key:, error:)]
+      in [_, [:error, error]]
+        return [:error, error_i18n("hash_value", key:, error:)]
+      end
+    end
+
+    [:ok, validated_hash]
+  end
+
+  concerning :Webpage do
+    def summary
+      "object"
+    end
+
+    def partial
+      "explicit/documentation/type/hash"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "object",
+        additionalProperties: valuetype.swagger_schema,
+        description: swagger_description([
+          empty == false ? swagger_i18n("hash_not_empty") : nil
+        ])
+      }
+    end
+  end
+end

data/lib/explicit/type/integer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+class Explicit::Type::Integer < Explicit::Type
+  attr_reader :min, :max, :negative, :positive
+
+  def initialize(min: nil, max: nil, negative: nil, positive: nil)
+    @min = min
+    @max = max
+    @negative = negative
+    @positive = positive
+  end
+
+  ParseFromString = ->(value) do
+    Integer(value)
+  rescue ::ArgumentError
+    nil
+  end
+
+  def validate(value)
+    value =
+      if value.is_a?(::Integer)
+        value
+      elsif value.is_a?(::String)
+        ParseFromString[value]
+      else
+        nil
+      end
+
+    return [:error, error_i18n("integer")] if value.nil?
+
+    if min && value < min
+      return [:error, error_i18n("min", min:)]
+    end
+
+    if max && value > max
+      return [:error, error_i18n("max", max:)]
+    end
+
+    if negative == false && value < 0
+      return [:error, error_i18n("not_negative")]
+    end
+
+    if positive == false && value > 0
+      return [:error, error_i18n("not_positive")]
+    end
+
+    [:ok, value]
+  end
+
+  concerning :Webpage do
+    def summary
+      "integer"
+    end
+
+    def partial
+      "explicit/documentation/type/integer"
+    end
+
+    def has_details?
+      min.present? || max.present? || !negative.nil? || !positive.nil?
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: "integer",
+        minimum: min,
+        maximum: max,
+        description: swagger_description([
+          positive == false ? swagger_i18n("integer_not_positive") : nil,
+          positive == true ? swagger_i18n("integer_only_positive") : nil,
+          negative == false ? swagger_i18n("integer_not_negative") : nil,
+          negative == true ? swagger_i18n("integer_only_negative") : nil
+        ])
+      }.compact_blank
+    end
+  end
+end

data/lib/explicit/type/literal.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Explicit::Type::Literal < Explicit::Type
+  attr_reader :value
+
+  def initialize(value:)
+    if !value.is_a?(::String) && !value.is_a?(::Integer)
+      raise ArgumentError("literal must be a string or integer") 
+    end
+
+    @value = value
+  end
+
+  def validate(value)
+    if value == @value
+      [:ok, value]
+    else
+      [:error, error_i18n("literal", value: @value.inspect)]
+    end
+  end
+
+  concerning :Webpage do
+    def summary
+      @value.inspect
+    end
+
+    def partial
+      nil
+    end
+
+    def has_details?
+      false
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      {
+        type: @value.is_a?(::String) ? "string" : "integer",
+        enum: [@value],
+        description: swagger_description([])
+      }
+    end
+  end
+end

data/lib/explicit/type/modifiers/default.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Explicit::Type::Modifiers::Default
+  extend self
+
+  def apply(default, type)
+    Explicit::Type.build(type).tap do |type|
+      type.default = default if type.is_a?(Explicit::Type) # TODO: remove check
+
+      original_validate = type.method(:validate)
+
+      type.define_singleton_method(:validate, lambda do |value|
+        value =
+          if value.nil?
+            default.respond_to?(:call) ? default.call : default
+          else
+            value
+          end
+
+        original_validate.(value)
+      end)
+    end
+  end
+end

data/lib/explicit/type/modifiers/description.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Explicit::Type::Modifiers::Description
+  extend self
+
+  def apply(description, type)
+    Explicit::Type.build(type).tap do |type|
+      type.description = description if type.is_a?(Explicit::Type) # TODO: remove check
+    end
+  end
+end

data/lib/explicit/type/modifiers/nilable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Explicit::Type::Modifiers::Nilable
+  extend self
+
+  def apply(type)
+    Explicit::Type.build(type).tap do |type|
+      type.nilable = true if type.is_a?(Explicit::Type) # TODO: remove check
+
+      original_validate = type.method(:validate)
+
+      type.define_singleton_method(:validate, lambda do |value|
+        return [:ok, nil] if value.nil?
+
+        original_validate.(value)
+      end)
+    end
+  end
+end

data/lib/explicit/type/modifiers/param_location.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Explicit::Type::Modifiers::ParamLocation
+  extend self
+
+  def apply(param_location, type)
+    Explicit::Type.build(type).tap do |type|
+      type.param_location = param_location
+    end
+  end
+end

data/lib/explicit/type/one_of.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Explicit::Type::OneOf < Explicit::Type
+  attr_reader :subtypes
+
+  def initialize(subtypes:)
+    @subtypes = subtypes.map { Explicit::Type.build(_1) }
+  end
+
+  def validate(value)
+    errors = []
+
+    @subtypes.each do |subtype|
+      case subtype.validate(value)
+      in [:ok, validated_value]
+        return [:ok, validated_value]
+      in [:error, err]
+        errors << err
+      end
+    end
+
+    [:error, errors.join(" OR ")]
+  end
+
+  concerning :Webpage do
+    def summary
+      @subtypes.all? { _1.is_a?(Explicit::Type::Record) } ? "object" : "any"
+    end
+
+    def partial
+      "explicit/documentation/type/one_of"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_schema
+      return subtypes.first.swagger_schema if subtypes.one?
+
+      { oneOf: subtypes.map(&:swagger_schema) }
+    end
+  end
+end

data/lib/explicit/type/record.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class Explicit::Type::Record < Explicit::Type
+  attr_reader :attributes
+
+  def initialize(attributes:)
+    @attributes = attributes.map do |attribute_name, type|
+      type = Explicit::Type.build(type) if !type.is_a?(Explicit::Type)
+
+      [attribute_name, type]
+    end
+  end
+
+  def validate(data)
+    return [:error, error_i18n("hash")] if !data.respond_to?(:[])
+
+    validated_data = {}
+    errors = {}
+
+    @attributes.each do |attribute_name, type|
+      value = data[attribute_name]
+
+      case type.validate(value)
+      in [:ok, validated_value]
+        validated_data[attribute_name] = validated_value
+      in [:error, err]
+        errors[attribute_name] = err
+      end
+    end
+
+    return [:error, errors] if errors.any?
+
+    [:ok, validated_data]
+  end
+
+  def path_params_type
+    path_params = @attributes.filter do |name, type|
+      type.param_location_path?
+    end
+
+    self.class.new(attributes: path_params)
+  end
+
+  def body_params_type
+    body_params = @attributes.filter do |name, type|
+      !type.param_location_path?
+    end
+
+    self.class.new(attributes: body_params)
+  end
+
+  concerning :Webpage do
+    def summary
+      "object"
+    end
+
+    def partial
+      "explicit/documentation/type/record"
+    end
+
+    def has_details?
+      true
+    end
+  end
+
+  concerning :Swagger do
+    def swagger_parameters
+      attributes.map do |name, type|
+        {
+          name:,
+          in: type.param_location_path? ? "path" : "body",
+          description: type.description,
+          required: !type.nilable,
+          schema: type.swagger_schema
+        }
+      end
+    end
+
+    def swagger_schema
+      properties = attributes.to_h do |name, type|
+        [name, type.swagger_schema]
+      end
+
+      required = attributes.filter_map do |name, type|
+        type.required? ? name.to_s : nil
+      end
+
+      {
+        type: "object",
+        properties:,
+        required:,
+        description: swagger_description([])
+      }.compact_blank
+    end
+  end
+end