explicit 0.2.0 → 0.2.2

data/lib/explicit/spec/date_time_posix.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module Explicit::Spec::DateTimePosix
-  extend self
-
-  ERROR_INVALID = [:error, :date_time_posix].freeze
-
-  def call(value)
-    if !value.is_a?(::Integer) && !value.is_a?(::String)
-      return ERROR_INVALID
-    end
-
-    datetimeval = DateTime.strptime(value.to_s, "%s")
-
-    [:ok, datetimeval]
-  rescue Date::Error
-    ERROR_INVALID
-  end
-end

data/lib/explicit/spec/default.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Default
-  extend self
-
-  def build(defaultval, subspec)
-    subspec_validator = Explicit::Spec::build(subspec)
-
-    lambda do |value|
-      value =
-        if value.nil?
-          defaultval.respond_to?(:call) ? defaultval.call : defaultval
-        else
-          value
-        end
-
-      subspec_validator.call(value)
-    end
-  end
-end

data/lib/explicit/spec/error.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Error
-  extend self
-
-  RailsI18n = ->(error, **context) do
-    key = "explicit.errors.#{error}"
-
-    ::I18n.t(key, **context)
-  end
-
-  def translate(error, translator = RailsI18n)
-    case error
-    in :agreement
-      translator.call(:agreement)
-    in [:array, index, suberr]
-      translator.call(:array, index:, error: translate(suberr, translator))
-    in :bigdecimal
-      translator.call(:bigdecimal)
-    in :boolean
-      translator.call(:boolean)
-    in :date_time_iso8601
-      translator.call(:date_time_iso8601)
-    in :date_time_posix
-      translator.call(:date_time_posix)
-    in :hash
-      translator.call(:hash)
-    in [:hash_key, key, suberr]
-      translator.call(:hash_key, key:, error: translate(suberr, translator))
-    in [:hash_value, key, suberr]
-      translator.call(:hash_value, key:, error: translate(suberr, translator))
-    in [:inclusion, values]
-      translator.call(:inclusion, values: values.inspect)
-    in :integer
-      translator.call(:integer)
-    in [:min, min]
-      translator.call(:min, min:)
-    in [:max, max]
-      translator.call(:max, max:)
-    in :negative
-      translator.call(:negative)
-    in :positive
-      translator.call(:positive)
-    in [:literal, value]
-      translator.call(:literal, value: value.inspect)
-    in [:one_of, *errors]
-      # TODO
-      errors.map { translate(_1, translator) }.join(" OR ")
-    in :string
-      translator.call(:string)
-    in :empty
-      translator.call(:empty)
-    in [:minlength, minlength]
-      translator.call(:minlength, minlength:)
-    in [:maxlength, maxlength]
-      translator.call(:maxlength, maxlength:)
-    in [:format, regex]
-      translator.call(:format, regex: regex.inspect)
-    in Hash
-      error.to_h { |attr_name, err| [attr_name, translate(err, translator)] }
-    end
-  end
-end

data/lib/explicit/spec/hash.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Hash
-  extend self
-
-  def build(keyspec, valuespec, options)
-    keyspec_validator = Explicit::Spec.build(keyspec)
-    valuespec_validator = Explicit::Spec.build(valuespec)
-
-    lambda do |value|
-      return [:error, :hash] if !value.is_a?(::Hash)
-      return [:error, :empty] if value.empty? && !options[:empty]
-
-      validated_hash = {}
-
-      value.each do |key, value|
-        case [keyspec_validator.call(key), valuespec_validator.call(value)]
-        in [[:ok, validated_key], [:ok, validated_value]]
-          validated_hash[validated_key] = validated_value
-        in [[:error, err], _]
-          return [:error, [:hash_key, key, err]]
-        in [_, [:error, err]]
-          return [:error, [:hash_value, key, err]]
-        end
-      end
-
-      [:ok, validated_hash]
-    end
-  end
-end

data/lib/explicit/spec/inclusion.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Inclusion
-  extend self
-
-  def build(values)
-    lambda do |value|
-      if values.include?(value)
-        [:ok, value]
-      else
-        [:error, [:inclusion, values]]
-      end
-    end
-  end
-end

data/lib/explicit/spec/integer.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Integer
-  extend self
-
-  def build(options)
-    lambda do |value|
-      value =
-        if value.is_a?(::Integer)
-          value
-        elsif value.is_a?(::String) && options[:parse]
-          parse_from_string(value)
-        else
-          nil
-        end
-
-      return [:error, :integer] if value.nil?
-
-      if (min = options[:min]) && !validate_min(value, min)
-        return [:error, [:min, min]]
-      end
-
-      if (max = options[:max]) && !validate_max(value, max)
-        return [:error, [:max, max]]
-      end
-
-      if options[:negative] == false && value < 0
-        return [:error, :negative]
-      end
-
-      if options[:positive] == false && value > 0
-        return [:error, :positive]
-      end
-
-      [:ok, value]
-    end
-  end
-
-  private
-    def parse_from_string(value)
-      Integer(value)
-    rescue ::ArgumentError
-      nil
-    end
-
-    def validate_min(value, min)
-      value >= min
-    end
-
-    def validate_max(value, max)
-      value <= max
-    end
-end

data/lib/explicit/spec/literal.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Literal
-  extend self
-
-  def build(literal_value)
-    lambda do |value|
-      if value == literal_value
-        [:ok, value]
-      else
-        [:error, [:literal, literal_value]]
-      end
-    end
-  end
-end

data/lib/explicit/spec/nilable.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Nilable
-  extend self
-
-  def build(subspec)
-    subspec_validator = Explicit::Spec.build(subspec)
-
-    lambda do |value|
-      return [:ok, nil] if value.nil?
-
-      subspec_validator.call(value)
-    end
-  end
-end

data/lib/explicit/spec/one_of.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::OneOf
-  extend self
-
-  def build(subspecs)
-    subspec_validators = subspecs.map { Explicit::Spec.build(_1) }
-
-    errors = []
-
-    lambda do |value|
-      subspec_validators.each do |subspec_validator|
-        case subspec_validator.call(value)
-        in [:ok, validated_value]
-          return [:ok, validated_value]
-        in [:error, err]
-          errors << err
-        end
-      end
-
-      errors.each do |err|
-        if looks_like_at_least_one_attribute_matched?(value, err)
-          return [:error, err]
-        end
-      end
-
-      [:error, [:one_of, *errors]]
-    end
-  end
-
-  private
-    def looks_like_at_least_one_attribute_matched?(value, err)
-      return false if !value.is_a?(::Hash)
-      return false if !err.is_a?(::Hash)
-
-      keyset = value.keys - err.keys
-
-      keyset.empty?
-    end
-end

data/lib/explicit/spec/record.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::Record
-  extend self
-
-  def build(attributes)
-    attributes_validators = attributes.map do |attribute_name, attribute_spec|
-      [attribute_name, Explicit::Spec.build(attribute_spec)]
-    end
-
-    lambda do |data|
-      return [:error, :hash] if !data.respond_to?(:[])
-
-      validated_data = {}
-      errors = {}
-
-      attributes_validators.each do |attribute_name, attribute_validator|
-        value = data[attribute_name]
-
-        case attribute_validator.call(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
-  end
-end

data/lib/explicit/spec/string.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec::String
-  extend self
-
-  def build(options)
-    lambda do |value|
-      return [:error, :string] if !value.is_a?(::String)
-
-      value = value.strip if options[:strip]
-
-      if options.key?(:empty) && !validate_empty(value, options[:empty])
-        return [:error, :empty]
-      end
-
-      if (minlength = options[:minlength]) && !validate_minlength(value, minlength)
-        return [:error, [:minlength, minlength:]]
-      end
-
-      if (maxlength = options[:maxlength]) && !validate_maxlength(value, maxlength)
-        return [:error, [:maxlength, maxlength:]]
-      end
-
-      if (format = options[:format]) && !validate_format(value, format)
-        return [:error, [:format, format]]
-      end
-
-      [:ok, value]
-    end
-  end
-
-  private
-    def validate_empty(value, allow_empty)
-      return true if allow_empty
-
-      !value.empty?
-    end
-
-    def validate_minlength(value, minlength)
-      value.length >= minlength
-    end
-
-    def validate_maxlength(value, maxlength)
-      value.length <= maxlength
-    end
-
-    def validate_format(value, format)
-      format.match?(value)
-    end
-end

data/lib/explicit/spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Explicit::Spec
-  extend self
-
-  def build(spec)
-    case spec
-    in :agreement
-      Explicit::Spec::Agreement.build({})
-    in [:agreement, options]
-      Explicit::Spec::Agreement.build(options)
-
-    in [:array, itemspec]
-      Explicit::Spec::Array.build(itemspec, {})
-    in [:array, itemspec, options]
-      Explicit::Spec::Array.build(itemspec, options)
-
-    in :bigdecimal
-      Explicit::Spec::Bigdecimal.build({})
-    in [:bigdecimal, options]
-      Explicit::Spec::Bigdecimal.build(options)
-
-    in :boolean
-      Explicit::Spec::Boolean.build({})
-    in [:boolean, options]
-      Explicit::Spec::Boolean.build(options)
-
-    in :date_time_iso8601
-      Explicit::Spec::DateTimeISO8601
-    in :date_time_posix
-      Explicit::Spec::DateTimePosix
-
-    in [:default, defaultval, subspec]
-      Explicit::Spec::Default.build(defaultval, subspec)
-
-    in [:description, _, subspec]
-      Explicit::Spec.build(subspec)
-
-    in [:hash, keyspec, valuespec]
-      Explicit::Spec::Hash.build(keyspec, valuespec, {})
-    in [:hash, keyspec, valuespec, options]
-      Explicit::Spec::Hash.build(keyspec, valuespec, options)
-
-    in [:inclusion, options]
-      Explicit::Spec::Inclusion.build(options)
-
-    in :integer
-      Explicit::Spec::Integer.build({})
-    in [:integer, options]
-      Explicit::Spec::Integer.build(options)
-
-    in [:literal, value]
-      Explicit::Spec::Literal.build(value)
-    in ::String
-      Explicit::Spec::Literal.build(spec)
-
-    in [:nilable, options]
-      Explicit::Spec::Nilable.build(options)
-
-    in [:one_of, *subspecs]
-      Explicit::Spec::OneOf.build(subspecs)
-
-    in :string
-      Explicit::Spec::String.build({})
-    in [:string, options]
-      Explicit::Spec::String.build(options)
-
-    in ::Hash
-      Explicit::Spec::Record.build(spec)
-    end
-  end
-end