pakyow-core 0.11.3 → 1.0.0.rc1

data/lib/pakyow/validations/length.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "pakyow/validator"
+
+module Pakyow
+  module Validations
+    # Validates that the value is of an expected length.
+    #
+    # @api public
+    module Length
+      def self.name
+        :length
+      end
+
+      def self.message(minimum: nil, maximum: nil, **)
+        if minimum && maximum
+          "must have between #{minimum} and #{maximum} characters"
+        elsif minimum
+          "must have more than #{minimum} #{wording(minimum)}"
+        elsif maximum
+          "must have less than #{maximum} #{wording(maximum)}"
+        end
+      end
+
+      def self.valid?(value, minimum: nil, maximum: nil, **)
+        unless minimum.nil?
+          return false if value.length < minimum
+        end
+
+        unless maximum.nil?
+          return false if value.length > maximum
+        end
+
+        true
+      end
+
+      def self.wording(n)
+        n == 1 ? "character" : "characters"
+      end
+    end
+
+    Validator.register_validation(Length)
+  end
+end

data/lib/pakyow/validations/presence.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "pakyow/validator"
+
+module Pakyow
+  module Validations
+    # Validates that the value is present, or that a value is non-empty, non-nil, and not a string
+    # consisting of whitespace only characters. Example values that will not pass this validation:
+    #
+    # * +nil+
+    # * +""+
+    # * +"   "+
+    # * +[]+
+    # * +{}+
+    #
+    # @api public
+    module Presence
+      WHITESPACE_ONLY = /^\s*$/
+
+      def self.name
+        :presence
+      end
+
+      def self.message(**)
+        "cannot be blank"
+      end
+
+      def self.valid?(value, **)
+        if value.is_a?(String)
+          !value.match?(WHITESPACE_ONLY)
+        elsif value.respond_to?(:empty?)
+          !value.empty?
+        else
+          !!value
+        end
+      end
+    end
+
+    Validator.register_validation(Presence)
+  end
+end

data/lib/pakyow/validations.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "pakyow/validations/inline"
+
+require "pakyow/validations/acceptance"
+require "pakyow/validations/email"
+require "pakyow/validations/length"
+require "pakyow/validations/presence"

data/lib/pakyow/validator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "pakyow/support/class_state"
+
+require "pakyow/errors"
+
+module Pakyow
+  class Validator
+    class Result
+      def initialize
+        @errors = []
+      end
+
+      def error(validation, options)
+        @errors << [validation, options]
+      end
+
+      def valid?
+        @errors.empty?
+      end
+
+      def messages
+        @errors.map { |validation, options|
+          options[:message] || validation.message(**options)
+        }
+      end
+    end
+
+    extend Support::ClassState
+    class_state :validation_objects, default: {}
+
+    class << self
+      def register_validation(validation_object)
+        @validation_objects[validation_object.name] = validation_object
+      end
+
+      def validation_object_for(validation)
+        @validation_objects[validation] || raise(
+          UnknownValidationError.new_with_message(validation: validation)
+        )
+      end
+    end
+
+    require "pakyow/validations"
+
+    def initialize(key = nil, &block)
+      @key = key
+      @validations = []
+
+      if block
+        instance_eval(&block)
+      end
+    end
+
+    def any?
+      @validations.any?
+    end
+
+    def validate(validation_name = nil, **options)
+      validation_object = if block_given?
+        Validations::Inline.new(validation_name, Proc.new)
+      else
+        self.class.validation_object_for(validation_name)
+      end
+
+      @validations << [validation_object, options]
+    end
+
+    def call(values, context: nil)
+      result = Result.new
+
+      @validations.each do |validation, options|
+        unless validation.valid?(values, key: @key, context: context, **options)
+          result.error(validation, options)
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/pakyow/verifier.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require "pakyow/support/core_refinements/array/ensurable"
+
+require "pakyow/types"
+require "pakyow/validator"
+
+module Pakyow
+  class Verifier
+    class Result
+      def initialize
+        @errors = {}
+        @nested = {}
+        @validation = nil
+      end
+
+      def error(key, message)
+        (@errors[key] ||= []) << message
+      end
+
+      def nested(key, result)
+        @nested[key] = result
+      end
+
+      def validation(result)
+        @validation = result
+      end
+
+      def verified?
+        @errors.empty? && (!validating? || @validation.valid?) && @nested.all? { |_, result|
+          result.verified?
+        }
+      end
+
+      def validating?
+        !@validation.nil?
+      end
+
+      def messages
+        if validating?
+          messages = @validation.messages
+        else
+          messages = {}
+
+          @errors.each_pair do |key, value|
+            messages[key] = value
+          end
+
+          @nested.each_pair do |key, verifier|
+            nested_messages = verifier.messages
+
+            unless nested_messages.empty?
+              messages[key] = nested_messages
+            end
+          end
+        end
+
+        messages
+      end
+    end
+
+    using Support::Refinements::Array::Ensurable
+
+    extend Forwardable
+    def_delegators :@validator, :validate
+
+    def initialize(key = nil, &block)
+      @key = key
+      @types = {}
+      @messages = {}
+      @required_keys = []
+      @optional_keys = []
+      @allowable_keys = []
+      @verifiers_by_key = {}
+      @validator = Validator.new(key)
+
+      if block
+        instance_eval(&block)
+      end
+    end
+
+    def required(key, type = nil, message: "is required", &block)
+      key = key.to_sym
+      @required_keys.push(key).uniq!
+      @allowable_keys.push(key).uniq!
+      @messages[key] = message
+
+      if type
+        @types[key] = Types.type_for(type)
+      end
+
+      if block
+        @verifiers_by_key[key] = self.class.new(key, &block)
+      end
+    end
+
+    def optional(key, type = nil, &block)
+      key = key.to_sym
+      @optional_keys.push(key).uniq!
+      @allowable_keys.push(key).uniq!
+
+      if type
+        @types[key] = Types.type_for(type)
+      end
+
+      if block
+        @verifiers_by_key[key] = self.class.new(key, &block)
+      end
+    end
+
+    def call(values, context: nil)
+      values ||= {}
+
+      if should_sanitize?(values)
+        values = sanitize(values)
+      end
+
+      result = Result.new
+
+      if should_validate?(values)
+        result.validation(@validator.call(values, context: context))
+      end
+
+      @allowable_keys.each do |allowable_key|
+        if values[allowable_key].nil?
+          if @required_keys.include?(allowable_key)
+            result.error(allowable_key, @messages[allowable_key])
+          else
+            next
+          end
+        end
+
+        if verifier_for_key = @verifiers_by_key[allowable_key]
+          Array.ensure(values[allowable_key]).each do |values_for_key|
+            result.nested(allowable_key, verifier_for_key.call(values_for_key, context: context))
+          end
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def sanitize(values)
+      values.select! do |key, _|
+        @allowable_keys.include?(key.to_sym)
+      end
+
+      @allowable_keys.each do |key|
+        key = key.to_sym
+
+        if values.key?(key)
+          value = values[key]
+
+          if type = @types[key]
+            value = type[value]
+          end
+
+          values[key] = value
+        end
+      end
+
+      values
+    end
+
+    def should_sanitize?(values)
+      values.is_a?(Pakyow::Support::IndifferentHash) || values.is_a?(Hash) || values.is_a?(Connection::Params)
+    end
+
+    def should_validate?(values)
+      @validator.any? && !values.nil?
+    end
+  end
+end

data/lib/pakyow.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "pakyow/version"
+require "pakyow/error"
+require "pakyow/environment"