saphyr 0.4.0.beta

data/lib/saphyr/fields/field_base.rb

@@ -0,0 +1,235 @@
+module Saphyr
+  module Fields
+
+    class FieldBase
+      # Prefix use to format error code
+      # @note You must Override this class constants in your field type class
+      PREFIX = 'base'
+
+      include Saphyr::Asserts::ErrorConstants
+      include Saphyr::Asserts::BaseAssert
+      include Saphyr::Asserts::SizeAssert
+      include Saphyr::Asserts::NumericAssert
+      include Saphyr::Asserts::StringAssert
+
+      # A hash containing the options of the field.
+      attr_reader :opts
+
+      # Every field type has the +:required+ and +:nullable+ options.
+      # @api private
+      DEFAULT_OPT_VALUES = {required: true, nullable: false}.freeze
+      # @api private
+      DEFAULT_OPTS = DEFAULT_OPT_VALUES.keys.freeze
+
+      # NOTE: 
+      # Override following constants to manage options
+
+      # List of authorized options.
+      # @note Override this class constant if you want to use this feature.
+      AUTHORIZED_OPTIONS = []
+
+      # List of required options.
+      # @note Override this class constant if you want to use this feature.
+      REQUIRED_OPTIONS = []
+
+      # Require one and only of the listed options.
+      # @note Override this class constant if you want to use this feature.
+      REQUIRED_ONE_OF_OPTIONS = []
+
+      # Definition of exclusive options
+      # @note Override this class constant if you want to use this feature.
+      EXCLUSIVE_OPTIONS = []
+
+      # List of options where value must not be equals to another option.
+      # (ex: min == max)
+      # @note Override this class constant if you want to use this feature.
+      NOT_EQUALS_OPTIONS = []
+
+      # List of options where value must not be superior to another option.
+      # (ex: lt > gt)
+      # @note Override this class constant if you want to use this feature.
+      NOT_SUP_OPTIONS = []
+
+      # List of options where value must not be superior or equals to another option.
+      # (ex: lt >= gt)
+      # @note Override this class constant if you want to use this feature.
+      NOT_SUP_OR_EQUALS_OPTIONS = []
+
+
+      def initialize(opts={})
+        if opts.key? :required
+          unless assert_boolean opts[:required]
+            raise Saphyr::Error.new "Option ':required' must be a Boolean"
+          end
+        end
+        if opts.key? :nullable
+          unless assert_boolean opts[:nullable]
+            raise Saphyr::Error.new "Option ':nullable' must be a Boolean"
+          end
+        end
+
+        unless authorized_options.size == 0
+          opts.keys.each do |opt|
+            next if  opt == :required or opt == :nullable
+            unless authorized_options.include? opt
+              raise Saphyr::Error.new "Unauthorized option: #{opt}"
+            end
+          end
+        end
+
+        required_options.each do |opt|
+          unless opts.include? opt
+            raise Saphyr::Error.new "Missing required option: '#{opt}'"
+          end
+        end
+
+        unless required_one_of_options.size == 0
+          status, selected = false, nil
+          required_one_of_options.each do |opt|
+            if opts.include? opt
+              if status
+                raise Saphyr::Error.new "You can't provide both options at same time: '#{selected}' and '#{opt}'"
+              end
+              status = true
+              selected = opt
+            end
+          end
+          unless status
+            raise Saphyr::Error.new "You must provide one of the following options: '#{required_one_of_options.to_s}'"
+          end
+        end
+
+        exclusive_options.each do |data|
+          opt, excluded = data
+          if opts.include? opt
+            if excluded.first == :_all_
+              excluded = authorized_options - [opt]
+            end
+            unless opts.keys.intersection(excluded).size == 0
+              raise Saphyr::Error.new "You can't use #{excluded.to_s} options, if you use #{opt.to_s} options, if you use : :#{opt}"
+            end
+          end
+        end
+
+        not_equals_options.each do |data|
+          opt1, opt2 = data
+          if opts.include? opt1 and opts.include? opt2
+            if opts[opt1] == opts[opt2]
+              raise Saphyr::Error.new "Option '#{opt1} cannot be > to '#{opt2}'"
+            end
+          end
+        end
+
+        not_sup_options.each do |data|
+          opt1, opt2 = data
+          if opts.include? opt1 and opts.include? opt2
+            if opts[opt1] > opts[opt2]
+              raise Saphyr::Error.new "Option '#{opt1} cannot be > to '#{opt2}'"
+            end
+          end
+        end
+
+        not_sup_or_equals_options.each do |data|
+          opt1, opt2 = data
+          if opts.include? opt1 and opts.include? opt2
+            if opts[opt1] >= opts[opt2]
+              raise Saphyr::Error.new "Option '#{opt1} cannot be >= to '#{opt2}'"
+            end
+          end
+        end
+
+        @opts = DEFAULT_OPT_VALUES.merge opts
+      end
+
+      # -----
+
+      # Get the +PREFIX+ setting.
+      # @return [String] The prefix
+      def prefix
+        self.class::PREFIX
+      end
+
+      # -----
+
+      # Get the +AUTHORIZED_OPTIONS+ options
+      # @return [Array]
+      def authorized_options
+        self.class::AUTHORIZED_OPTIONS
+      end
+
+      # Get the +REQUIRED_OPTIONS+ options
+      # @return [Array]
+      def required_options
+        self.class::REQUIRED_OPTIONS
+      end
+
+      # Get the +REQUIRED_ONE_OF_OPTIONS+ options
+      # @return [Array]
+      def required_one_of_options
+        self.class::REQUIRED_ONE_OF_OPTIONS
+      end
+
+      # Get the +EXCLUSIVE_OPTIONS+ options
+      # @return [Array]
+      def exclusive_options
+        self.class::EXCLUSIVE_OPTIONS
+      end
+
+      # Get the +NOT_EQUALS_OPTIONS+ options
+      # @return [Array]
+      def not_equals_options
+        self.class::NOT_EQUALS_OPTIONS
+      end
+
+      # Get the +NOT_SUP_OPTIONS+ options
+      # @return [Array]
+      def not_sup_options
+        self.class::NOT_SUP_OPTIONS
+      end
+
+      # Get the +NOT_SUP_OR_EQUALS_OPTIONS+ options
+      # @return [Array]
+      def not_sup_or_equals_options
+        self.class::NOT_SUP_OR_EQUALS_OPTIONS
+      end
+
+      # -----
+
+      # Format the error code with the field prefix.
+      # @param code [String] The error code.
+      # @return [String] The formatted error code.
+      def err(code)
+        prefix + ':' + code
+      end
+
+      # Is the field required?
+      def required?
+        @opts[:required]
+      end
+
+      # Is the field nullable?
+      def nullable?
+        @opts[:nullable]
+      end
+
+      # -----
+
+      # Check if the field value is valid.
+      # @param ctx [Saphyr::Engine::Context] The engine context.
+      # @param name [String] The field name.
+      # @param value [String] The field value.
+      def validate(ctx, name, value)
+        # NOTE: Nullable is handle by the engine.
+        errors = []
+        do_validate ctx, name, value, errors
+        errors
+      end
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          raise Saphyr::Error.new 'Not implemented!'
+        end
+    end
+  end
+end

data/lib/saphyr/fields/float_field.rb

@@ -0,0 +1,49 @@
+module Saphyr
+  module Fields
+
+    # The +float+ field type
+    #
+    # Allowed options are: +:eq, :gt, :gte, :lt, :lte, :in+.
+    class FloatField < FieldBase
+      PREFIX = 'float'
+
+      AUTHORIZED_OPTIONS = [:eq, :gt, :gte, :lt, :lte, :in]
+
+      EXCLUSIVE_OPTIONS = [
+        [ :eq, [:_all_] ],
+        [ :in, [:_all_] ],
+        [ :gt, [:gte] ],
+        [ :lt, [:lte] ],
+      ]
+
+      # Cannot have: lte == gte, use +:eq+ instead
+      NOT_EQUALS_OPTIONS = [
+        [:lte, :gte],
+      ]
+
+      # Cannot have: gte > lte
+      NOT_SUP_OPTIONS = [
+        [:gte, :lte],
+      ]
+
+      # Cannot have: gt >= lt ... and so on
+      NOT_SUP_OR_EQUALS_OPTIONS = [
+        [:gt, :lt],
+        [:gt, :lte],
+        [:gte, :lt],
+      ]
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_class Float, value, errors
+          assert_eq @opts[:eq], value, errors
+          assert_numeric_gt @opts[:gt], value, errors
+          assert_numeric_gte @opts[:gte], value, errors
+          assert_numeric_lt @opts[:lt], value, errors
+          assert_numeric_lte @opts[:lte], value, errors
+          assert_in @opts[:in], value, errors
+        end
+    end
+  end
+end

data/lib/saphyr/fields/integer_field.rb

@@ -0,0 +1,49 @@
+module Saphyr
+  module Fields
+
+    # The +integer+ field type
+    #
+    # Allowed options are: +:eq, :gt, :gte, :lt, :lte, :in+.
+    class IntegerField < FieldBase
+      PREFIX = 'integer'
+
+      AUTHORIZED_OPTIONS = [:eq, :gt, :gte, :lt, :lte, :in]
+
+      EXCLUSIVE_OPTIONS = [
+        [ :eq, [:_all_] ],
+        [ :in, [:_all_] ],
+        [ :gt, [:gte] ],
+        [ :lt, [:lte] ],
+      ]
+
+      # Cannot have: lte == gte, use +:eq+ instead
+      NOT_EQUALS_OPTIONS = [
+        [:lte, :gte],
+      ]
+
+      # Cannot have: gte > lte
+      NOT_SUP_OPTIONS = [
+        [:gte, :lte],
+      ]
+
+      # Cannot have: gt >= lt ... and so on
+      NOT_SUP_OR_EQUALS_OPTIONS = [
+        [:gt, :lt],
+        [:gt, :lte],
+        [:gte, :lt],
+      ]
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_class Integer, value, errors
+          assert_eq @opts[:eq], value, errors
+          assert_numeric_gt @opts[:gt], value, errors
+          assert_numeric_gte @opts[:gte], value, errors
+          assert_numeric_lt @opts[:lt], value, errors
+          assert_numeric_lte @opts[:lte], value, errors
+          assert_in @opts[:in], value, errors
+        end
+    end
+  end
+end

data/lib/saphyr/fields/schema_field.rb

@@ -0,0 +1,26 @@
+module Saphyr
+  module Fields
+
+    class SchemaField < FieldBase
+      PREFIX = 'schema'
+
+      AUTHORIZED_OPTIONS = [:name]
+
+      REQUIRED_OPTIONS = [:name]
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          # Find the schema
+          schema_name = @opts[:name]
+          schema = ctx.find_schema schema_name    # Raise exceeption if not found
+
+          # Create derived engine to handle schema and data fragment.
+          field_path = ctx.get_path name
+          new_ctx = ctx.derive schema, value, field_path
+          engine = Saphyr::Engine.new new_ctx
+          engine.validate
+        end
+    end
+  end
+end

data/lib/saphyr/fields/string_field.rb

@@ -0,0 +1,41 @@
+module Saphyr
+  module Fields
+
+    # The +string+ field type
+    #
+    # Allowed options are: +:eq, :len, :min, :max, :in, :regexp+.
+    class StringField < FieldBase
+      PREFIX = 'string'
+
+      AUTHORIZED_OPTIONS = [:eq, :len, :min, :max, :in, :regexp]
+
+      EXCLUSIVE_OPTIONS = [
+        [ :eq, [:_all_] ],
+        [ :len, [:eq, :min, :max, :in] ],
+        [ :in, [:_all_] ],
+      ]
+
+      # Cannot have: min == max, use +:len+ instead
+      NOT_EQUALS_OPTIONS = [
+        [:min, :max],
+      ]
+
+      # Cannot have: min > max
+      NOT_SUP_OPTIONS = [
+        [:min, :max],
+      ]
+
+      private
+
+        def do_validate(ctx, name, value, errors)
+          return unless assert_class String, value, errors
+          assert_eq @opts[:eq], value, errors
+          assert_size_len @opts[:len], value, errors
+          assert_size_min @opts[:min], value, errors
+          assert_size_max @opts[:max], value, errors
+          assert_in @opts[:in], value, errors
+          assert_string_regexp @opts[:regexp], value, errors
+        end
+    end
+  end
+end

data/lib/saphyr/fields.rb

@@ -0,0 +1,13 @@
+module Saphyr
+  module Fields
+    require_relative './fields/field_base'
+
+    require_relative './fields/array_field'
+    require_relative './fields/schema_field'
+
+    require_relative './fields/string_field'
+    require_relative './fields/integer_field'
+    require_relative './fields/float_field'
+    require_relative './fields/boolean_field'
+  end
+end

data/lib/saphyr/helpers/format.rb

@@ -0,0 +1,106 @@
+module Saphyr
+  module Helpers
+    class Format
+      class << self
+        def errors_to_text errors
+          errors.each do |error|
+            type = error[:type]
+            puts "path: #{error[:path]}"
+            errs = error[:errors]
+            errs.each do |err|
+              puts "  - type: #{err[:type]}"
+              puts "  - data: #{err[:data].to_s}"
+              puts "  - msg: #{make_msg err}"
+            end
+            puts ''
+          end
+        end
+
+        def make_msg(err)
+          type = err[:type]
+          data = err[:data]
+
+          # ------------------------------------
+          # BASE
+          # ------------------------------------
+          # eq
+          if type.end_with? 'eq'
+            return "Expecting value to be equals to: #{data[:eq]}, got: #{data[:_val]}"
+          end
+          # class
+          if type.end_with? 'type'
+            return "Expecting type '#{data[:type]}', got: #{data[:got]}"
+          end
+          # in
+          if type.end_with? 'in'
+            return "Expecting value to be in: #{data[:in].to_s}, got: #{data[:_val]}"
+          end
+
+          # ------------------------------------
+          # Numeric
+          # ------------------------------------
+          # gt
+          if type.end_with? 'gt'
+            return "Expecting value to be > #{data[:gt]}, got: #{data[:_val]}"
+          end
+          # gte
+          if type.end_with? 'gte'
+            return "Expecting value to be >= #{data[:gte]}, got: #{data[:_val]}"
+          end
+          # lt
+          if type.end_with? 'lt'
+            return "Expecting value to be < #{data[:lt]}, got: #{data[:_val]}"
+          end
+          # lte
+          if type.end_with? 'lte'
+            return "Expecting value to be <= #{data[:lte]}, got: #{data[:_val]}"
+          end
+
+          # ------------------------------------
+          # Size
+          # ------------------------------------
+          # len
+          if type.end_with? 'len'
+            return "Expecting size to be equals to: #{data[:len]}, got: #{data[:_val].size}"
+          end
+          # min
+          if type.end_with? 'min'
+            return "Expecting size to be >= #{data[:min]}, got: #{data[:_val].size}"
+          end
+          # max
+          if type.end_with? 'max'
+            return "Expecting size to be <= #{data[:max]}, got: #{data[:_val].size}"
+          end
+
+          # ------------------------------------
+          # String
+          # ------------------------------------
+          # regexp
+          if type.end_with? 'regexp'
+            return "Value failed to match regexp: #{data[:regexp].to_s}, got: #{data[:_val]}"
+          end
+
+          # ------------------------------------
+          # Strict mode
+          # ------------------------------------
+          if type.end_with? 'missing_in_data'
+            return 'Missing fields in data'
+          end
+
+          if type.end_with? 'missing_in_schema'
+            return 'Missing fields in schema'
+          end
+
+          # ------------------------------------
+          # Not Nullable
+          # ------------------------------------
+          if type == 'not-nullable'
+            return 'Not nullable'
+          end
+
+          'unknown'
+        end
+      end
+    end
+  end
+end

data/lib/saphyr/helpers.rb

@@ -0,0 +1,7 @@
+module Saphyr
+  module Helpers
+
+    require_relative './helpers/format'
+
+  end
+end

data/lib/saphyr/schema.rb

@@ -0,0 +1,73 @@
+module Saphyr
+
+  # This class is used to encapsulate schema definition.
+  #
+  class Schema
+    attr_reader :strict, :root, :fields, :schemas, :conditionals, :casts
+
+    def initialize()
+      @strict, @root = true, :object        # Default values
+      @fields, @schemas, @conditionals, @casts = {}, {}, [], {}
+    end
+
+    # ---------------------------------------------------- DSL
+    def strict(value)
+      @strict = value              # TODO: Validate bollean
+    end
+
+    def root(value)
+      @root = value                # TODO : Validate symbol -> :object or :array
+    end
+
+    def field(name, type, **opts)
+      # TODO : What if field 'name' already exists?
+      name_s = name.to_s                  # Convert Symbol to string
+      # Raise exceptions if field type is not found
+      @fields[name_s] = Saphyr.config.instanciate_field_type type, opts
+    end
+
+    def schema(name, &block)
+      schema = Saphyr::Schema.new
+      schema.instance_eval &block
+      # TODO : What if schema 'name' already exists?
+      @schemas[name] = schema
+    end
+
+    def conditional(cond, &block)
+      cond = cond.to_sym if cond.is_a? String
+      if not cond.is_a?(Proc) and not cond.is_a?(Symbol)
+        raise Saphyr::Error.new "Bad condition, must a Proc or Symbol"
+      end
+
+      schema = Saphyr::Schema.new
+      schema.instance_eval &block
+      @conditionals << [cond, schema]
+    end
+
+    def cast(field, method)
+      method = method.to_s if method.is_a? Symbol
+      if not method.is_a?(Proc) and not method.is_a?(String)
+        raise Saphyr::Error.new "Bad method, must a Proc or Symbol | String"
+      end
+      @casts.store field.to_s, method
+    end
+    # -------------------------------------------------- / DSL
+
+    # Find local schema definition
+    def find_schema(name)
+      @schemas[name]
+    end
+
+    def strict?
+      @strict
+    end
+
+    def root_array?
+      @root == :array
+    end
+
+    def root_object?
+      @root == :object
+    end
+  end
+end