saphyr 0.4.0.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 48f8284121fe854fd431ed4afa7a656206c17d4d1ddcb21ad6540db9ece53f15
+  data.tar.gz: 454d04e4c206d9bf827690a656d8d60573ebebfb6a625af409e4b1be560d038e
+SHA512:
+  metadata.gz: 16b265ab45002d654a716b994c6df15b48eafdd4617d3e1cc6e968905a5bd7172458c63c37213e3e2c1051a041b1cd1da9b97d108aba586b6b92137e5d7b8798
+  data.tar.gz: 0305d518e223973cb92c269030cb356d30d7c609e8abf86899cc6ab017164e853258bf67989a76c8e39521c6b804ced86254e42131afd851c0629022c7711a4b

data/CHANGELOG

@@ -0,0 +1,7 @@
+No changelog update during all the beta development phase.
+
+-----------------------------------------------------------------
+Version: 0.1.0.beta - 2023-08-30
+-----------------------------------------------------------------
+
+- Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Olivier Delbos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/saphyr/asserts/base_assert.rb

@@ -0,0 +1,58 @@
+module Saphyr
+  module Asserts
+
+    module BaseAssert
+      def assert_boolean value
+        value.is_a? TrueClass or value.is_a? FalseClass
+      end
+
+      def assert_class klass, value, errors, error_code=Fields::FieldBase::ERR_TYPE
+        klass = [klass] unless klass.is_a? Array
+        test = false
+        klass.each do |k|
+          if value.is_a? k; test = true; break; end
+        end
+        unless test
+          errors << {
+            type: err(error_code),
+            data: {
+              type: klass.to_s,
+              got: value.class.name,
+            }
+          }
+        end
+        test
+      end
+
+      def assert_eq opt_value, value, errors, error_code=Fields::FieldBase::ERR_EQ
+        return nil if opt_value.nil?
+        unless value == opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              eq: opt_value,
+            }
+          }
+          return false
+        end
+        true
+      end
+
+      def assert_in opt_values, value, errors, error_code=Fields::FieldBase::ERR_IN
+        return nil if opt_values.nil?
+        unless opt_values.include? value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              in: opt_values,
+            }
+          }
+          return false
+        end
+        true
+      end
+    end
+  end
+end

data/lib/saphyr/asserts/error_constants.rb

@@ -0,0 +1,28 @@
+module Saphyr
+  module Asserts
+
+    module ErrorConstants
+      # Base
+      ERR_NOT_NULLABLE = 'not-nullable'
+      ERR_BAD_FORMAT = 'bad-format'
+      ERR_TYPE = 'type'
+      ERR_IN = 'in'
+      ERR_EQ = 'eq'
+      # Size
+      ERR_SIZE_EQ = 'size-eq'
+      ERR_SIZE_LEN = 'size-len'
+      ERR_SIZE_MIN = 'size-min'
+      ERR_SIZE_MAX = 'size-max'
+      # Numeric
+      ERR_GT = 'gt'
+      ERR_GTE = 'gte'
+      ERR_LT = 'lt'
+      ERR_LTE = 'lte'
+      # String
+      ERR_LEN = 'len'
+      ERR_MIN = 'min'
+      ERR_MAX = 'max'
+      ERR_REGEXP = 'regexp'
+    end
+  end
+end

data/lib/saphyr/asserts/numeric_assert.rb

@@ -0,0 +1,66 @@
+module Saphyr
+  module Asserts
+
+    module NumericAssert
+      def assert_numeric_gt opt_value, value, errors, error_code=Fields::FieldBase::ERR_GT
+        return nil if opt_value.nil?
+        if value <= opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              gt: opt_value,
+            }
+          }
+          return false
+        end
+        true
+      end
+
+      def assert_numeric_gte opt_value, value, errors, error_code=Fields::FieldBase::ERR_GTE
+        return nil if opt_value.nil?
+        if value < opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              gte: opt_value,
+            }
+          }
+          return false
+        end
+        true
+      end
+
+      def assert_numeric_lt opt_value, value, errors, error_code=Fields::FieldBase::ERR_LT
+        return nil if opt_value.nil?
+        if value >= opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              lt: opt_value,
+            }
+          }
+          return false
+        end
+        true
+      end
+
+      def assert_numeric_lte opt_value, value, errors, error_code=Fields::FieldBase::ERR_LTE
+        return nil if opt_value.nil?
+        if value > opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              lte: opt_value,
+            }
+          }
+          return false
+        end
+        true
+      end
+    end
+  end
+end

data/lib/saphyr/asserts/size_assert.rb

@@ -0,0 +1,54 @@
+module Saphyr
+  module Asserts
+
+    module SizeAssert
+      def assert_size_len opt_value, value, errors, error_code=Fields::FieldBase::ERR_SIZE_LEN
+        return nil if opt_value.nil?
+        unless value.size == opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              len: opt_value,
+              got: value.size,
+            }
+          }
+          return false
+        end
+        true
+      end
+
+      def assert_size_min opt_value, value, errors, error_code=Fields::FieldBase::ERR_SIZE_MIN
+        return nil if opt_value.nil?
+        if value.size < opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              min: opt_value,
+              got: value.size,
+            }
+          }
+          return false
+        end
+        true
+      end
+
+      def assert_size_max opt_value, value, errors, error_code=Fields::FieldBase::ERR_SIZE_MAX
+        return nil if opt_value.nil?
+        if value.size > opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              max: opt_value,
+              got: value.size,
+            }
+          }
+          return false
+        end
+        true
+      end
+    end
+  end
+end

data/lib/saphyr/asserts/string_assert.rb

@@ -0,0 +1,21 @@
+module Saphyr
+  module Asserts
+
+    module StringAssert
+      def assert_string_regexp opt_value, value, errors, error_code=Fields::FieldBase::ERR_REGEXP
+        return nil if opt_value.nil?
+        unless value =~ opt_value
+          errors << {
+            type: err(error_code),
+            data: {
+              _val: value,
+              regexp: opt_value,
+            }
+          }
+          return false
+        end
+        true
+      end
+    end
+  end
+end

data/lib/saphyr/asserts.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Saphyr
+  # Group all modules related to atomic assertions.
+  #
+  # @api private
+  module Asserts
+  end
+end
+
+require_relative './asserts/error_constants'
+require_relative './asserts/base_assert'
+require_relative './asserts/size_assert'
+require_relative './asserts/numeric_assert'
+require_relative './asserts/string_assert'

data/lib/saphyr/engine.rb

@@ -0,0 +1,220 @@
+require 'json'
+
+module Saphyr
+
+  # The engine used to handle the validation processus.
+  # @api private
+  class Engine
+
+    # Class used to encapsule the validation engine context.
+    # @api private
+    class Context
+      attr_reader :validators, :schema, :data, :fragment, :path, :errors
+
+      def initialize(validators, schema, data, fragment, path, errors=[])
+        @validators = validators
+        @schema = schema
+        @data = data
+        @fragment = fragment
+        @path = path
+        @errors = errors
+      end
+
+      # Create a new context derived from the current one.
+      # @param schema [Saphyr::Schema] The schema associated with the new context.
+      # @param fragment [Hash] The data fragment.
+      # @param path [String] The path of the new context.
+      def derive(schema, fragment, path)
+        Context.new @validators, schema, @data, fragment, path, @errors
+      end
+
+      # Get the current field path from the root of the document.
+      # @return [String]
+      def get_path(name)
+        return @path + name if @path == '//'
+        return @path if name == ''
+        @path + '.' + name
+      end
+
+      # Find a schema given his name.
+      # Lookup first into the local validators if there isn't any schema found then
+      # lookup into the global schemas.
+      # @param name [Symbol] The name of the schema.
+      # @return [Saphyr::Schema]
+      # @rmaise [Saphyr::Error] if no schema was found.
+      def find_schema(name)
+        @validators.each do |validator|
+          schema = validator.find_schema name
+          return schema unless schema.nil?
+        end
+        schema = Saphyr.global_schema name
+        raise Saphyr::Error.new "Cannot find schema name: #{name}" if schema.nil?
+        schema
+      end
+
+      # Get data needed for validation
+      # @return The full data or a fragment of data is it exists.
+      def data_to_validate()
+        return @data if @fragment.nil?
+        @fragment
+      end
+    end
+
+    # -----
+
+    def initialize(ctx)
+      @ctx = ctx
+    end
+
+    def validate
+      array_validation if @ctx.schema.root_array?
+      object_validation if @ctx.schema.root_object?
+    end
+
+    private
+
+      def array_validation()
+        fields = @ctx.schema.fields
+        unless fields.size == 1
+          raise Saphyr::Error.new 'When root is :array, only :_root_ field must exists'
+        end
+
+        field = fields['_root_']
+        if field.nil?
+          raise Saphyr::Error.new 'When root is :array, must define :_root_ field'
+        end
+
+        errors = field.validate @ctx, '', @ctx.data_to_validate
+        unless errors.size == 0
+          @ctx.errors << {
+            path: '//',
+            errors: errors,
+          }
+        end
+      end
+
+      def object_validation()
+        # Computte all conditional fields
+        allowed_cond_fields = []
+        forbidden_cond_fields = []
+        @ctx.schema.conditionals.each do |data|
+          condition, schema = data
+          if @ctx.validators.last.send condition
+            allowed_cond_fields += schema.fields.keys
+          else
+            forbidden_cond_fields += schema.fields.keys
+          end
+        end
+
+        do_validation @ctx.schema, allowed_cond_fields, forbidden_cond_fields, []
+
+        fields = @ctx.schema.fields.keys
+        @ctx.schema.conditionals.each do |data|
+          condition, schema = data
+
+          if @ctx.validators.last.send condition
+            do_validation schema, allowed_cond_fields, forbidden_cond_fields, fields
+          end
+        end
+      end
+
+      def do_validation(schema, allowed_cond_fields, forbidden_cond_fields, exclude_fields)
+        data = @ctx.data_to_validate
+
+        # Apply casting
+        schema.casts.each_pair do |field, method|
+          data[field] = @ctx.validators.last.send method, data[field]
+        end
+
+        fields = schema.fields
+        field_keys = fields.keys
+        data_keys = data.keys
+
+        field_names = field_keys.union data_keys
+        field_names.each do |name|
+          field_path = @ctx.get_path name
+          field = fields[name]
+
+          if field.nil?
+            next unless @ctx.schema.strict?
+            next if allowed_cond_fields.include? name
+            next if exclude_fields.include? name
+
+            # If there is already an error for this field we skip adding a new one
+            # Bacause if there are many conditional schema, each one will add
+            # the field errors.
+            k = @ctx.errors.select { |err| err[:path] == field_path }
+            next if k.size != 0
+
+            if forbidden_cond_fields.include? name
+              @ctx.errors << {
+                path: field_path,
+                errors: [
+                  {
+                    type: 'conditional:not-allowed',
+                    data: { field: name }
+                  },
+                ],
+              }
+            else
+              @ctx.errors << {
+                path: field_path,
+                errors: [
+                  {
+                    type: 'strict_mode:missing_in_schema',
+                    data: { field: name }
+                  },
+                ],
+              }
+            end
+            next
+          end
+
+          unless data.key? name
+            next unless @ctx.schema.strict?
+            if field.required?
+              @ctx.errors << {
+                path: field_path,
+                errors: [
+                  {
+                    type: 'strict_mode:missing_in_data',
+                    data: {
+                      field: name,
+                    }
+                  }
+                ],
+              }
+            end
+            next
+          end
+
+          value = data[name]
+
+          if value.nil?
+            unless field.nullable?
+              @ctx.errors << {
+                path: field_path,
+                errors: [
+                  {
+                    type: Saphyr::Fields::FieldBase::ERR_NOT_NULLABLE,
+                    data: {
+                      field: name,
+                    }
+                  }
+                ],
+              }
+            end
+            next
+          end
+
+          errors = field.validate @ctx, name, value
+          unless errors.size == 0
+            @ctx.errors << {
+              path: field_path,
+              errors: errors,
+            }
+          end
+        end
+      end
+  end
+end

data/lib/saphyr/fields/array_field.rb

@@ -0,0 +1,80 @@
+module Saphyr
+  module Fields
+
+    class ArrayField < FieldBase
+      PREFIX = 'array'
+
+      AUTHORIZED_OPTIONS = [:len, :min, :max, :of_type, :of_schema, :opts]
+
+      REQUIRED_ONE_OF_OPTIONS = [:of_type, :of_schema]
+
+      EXCLUSIVE_OPTIONS = [
+        [ :len, [:min, :max] ],
+        [ :of_schema, [:opts] ],
+      ]
+
+      # Cannot have: min == max, use +:len+ instead
+      NOT_EQUALS_OPTIONS = [
+        [:min, :max],
+      ]
+
+      # Cannot have: min > max
+      NOT_SUP_OPTIONS = [
+        [:min, :max],
+      ]
+
+      def initialize(opts={})
+        super
+
+        # TODO : Check that :of_type exists
+
+        # TODO : Check that :of_schema exists
+      end
+
+      private 
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_class Array, value, errors
+          assert_size_len @opts[:len], value, errors
+          assert_size_min @opts[:min], value, errors
+          assert_size_max @opts[:max], value, errors
+
+          of_type = @opts[:of_type]
+          unless of_type.nil?
+            opts = {}
+            field_type_opts = @opts[:opts]
+            opts = field_type_opts unless field_type_opts.nil?
+
+            # Raise exception if field type is not found
+            field_type = Saphyr.config.instanciate_field_type of_type, opts
+            value.each_with_index do |current, index|
+              field_path = make_path ctx, name, index
+              errors = field_type.validate ctx, name, current
+              if errors.size != 0
+                ctx.errors << {
+                  path: field_path,
+                  errors: errors,
+                }
+              end
+            end
+          end
+
+          of_schema = @opts[:of_schema]
+          unless of_schema.nil?
+            value.each_with_index do |current, index|
+              field_path = make_path ctx, name, index
+              schema = ctx.find_schema of_schema      # Raise exceptions if not found
+              new_ctx = ctx.derive schema, current, field_path
+              engine = Saphyr::Engine.new new_ctx
+              engine.validate
+            end
+          end
+        end
+
+        def make_path(ctx, name, index)
+          return ctx.get_path "[#{index}]" if name == ''
+          ctx.get_path "#{name}.[#{index}]"
+        end
+    end
+  end
+end

data/lib/saphyr/fields/boolean_field.rb

@@ -0,0 +1,20 @@
+module Saphyr
+  module Fields
+
+    # The +boolean+ field type
+    #
+    # Allowed options are: +:eq+.
+    class BooleanField < FieldBase
+      PREFIX = 'boolean'
+
+      AUTHORIZED_OPTIONS = [:eq]
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_class [TrueClass, FalseClass], value, errors
+          assert_eq @opts[:eq], value, errors
+        end
+    end
+  end
+end