typero 0.8.0 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba656a56b8d2e5d3d977a2973f6de881eefd3257397a4a4ebe908a7abaed70a7
-  data.tar.gz: 8374f340b6af235c274ceaa9aace33f0c462b5a203d667a199fa519c1f56f53e
+  metadata.gz: 0f8d03e15d714e38774a8f817aaf02c710e3ddca8b65f9d413aefb01678bd31b
+  data.tar.gz: ebd4cb0d01d43f7a93c3e2575daa832ba960dd8ece2a284676c763f4c43ef30c
 SHA512:
-  metadata.gz: ba14e29595a5d17c3c3d102f49d1234a82e7ea23a7062a4a61c6dc56770d9d4922f1be7ae01663c41382efb6c6c51ed3fb5dfd4c188315ec1a5bf3f43eb699fc
-  data.tar.gz: c2d8b322fac4048067b809bf7944c8ca27bb787d4b590a68eec62169a768a65ddbb089359da73f550a32b59a0405b95629ae4932bf7a3dfb9d5426e2e26d3e7d
+  metadata.gz: 7a8dc1fdac410f59695f486860f078359a8344492335759b2df69f2fa382e3366000d70d994c4c05bdfa613c6c9dc207b66fefd2e4731f97dca97f94eda94b85
+  data.tar.gz: e7c6581d6fc6558687b023505564c669f59ce8e5dc0a298392f83fab92e1f47b27704a0b7644143161c6a264d601c2ac2a382c8cc0bdfb54f97ea52789846891

data/.version

@@ -1 +1 @@
-0.8.0
+0.9.4

data/lib/adapters/sequel.rb

@@ -3,60 +3,43 @@
 module Sequel::Plugins::TyperoAttributes
   module ClassMethods
     def typero
-      Typero.new self
+      Typero.schema self
     end
   end
 
   module InstanceMethods
     # calling typero! on any object will validate all fields
-    def typero! field_name=nil
-      return unless Typero.defined?(self.class)
+    def validate
+      super
 
-      typero = self.class.typero
+      schema = Typero.schema(self.class) || return
 
-      typero.validate(self) do |name, err|
+      schema.validate(self) do |name, err|
         errors.add(name, err) unless (errors.on(name) || []).include?(err)
       end
 
       # this are rules unique to database, so we check them here
-      typero.rules.each do |field, rule|
-        self[field] ||= {} if rule[:type] == 'hash'
-
+      schema.rules.each do |field, rule|
         # check uniqe fields
-        if rule[:unique]
+        if unique = rule.dig(:meta, :unique)
           id    = self[:id] || 0
           value = self[field]
 
           # we only check if field is changed
           if value.present? && column_changed?(field) && self.class.xwhere('LOWER(%s)=LOWER(?) and id<>?' % field, value, id).first
-            error = rule[:unique].class == TrueClass ? %[Value '"#{value}"' for #{field} allready exists] : rule[:unique]
+            error = unique.class == TrueClass ? %[Value "#{value}" for field "#{field}" has been already used, please chose another value.] : unique
             errors.add(field, error) unless (errors.on(field) || []).include?(error)
           end
         end
 
         # check protected fields
-        if rule[:protected] && self[:id]
+        if prot = rule.dig(:meta, :protected) && self[:id]
           if column_changed?(field)
-            error = rule[:protected].class == TrueClass ? "value once defined can't be overwritten." : rule[:protected]
+            error = prot.class == TrueClass ? "value once defined can't be overwritten." : prot
             errors.add(field, error) unless (errors.on(field) || []).include?(error)
           end
         end
       end
-
-      # check single field if single field given
-      if field_name
-        raise ArgumentError.new 'Field :%s not found in %s' % [field_name, self] unless self[field_name]
-        return unless errors.on(field_name)
-
-        errors.on(field_name).join(', ')
-      end
-
-      true
-    end
-
-    def validate
-      typero!
-      super
     end
   end
 

data/lib/typero.rb

@@ -1,5 +1,8 @@
+# require 'hash_wia'
+
 # base libs
 require_relative 'typero/typero'
+require_relative 'typero/schema'
 require_relative 'typero/params'
 require_relative 'typero/type/type'
 

data/lib/typero/params.rb

@@ -1,10 +1,8 @@
 # Base class for schema validation
 
-class Typero
+module Typero
   class Params
-    ALLOWED = %i(name min max default allowed delimiter max_count req required type array meta desc description duplicates unique)
-
-    attr_reader :rules, :db_rules
+    attr_reader :db_rules
 
     def initialize &block
       @db_rules = []
@@ -12,10 +10,14 @@ class Typero
       instance_exec &block
     end
 
+    def rules
+      @rules.dup
+    end
+
     private
 
     # used in dsl to define schema field options
-    def set field, *args
+    def set field, *args, &block
       raise "Field name not given (Typero)" unless field
 
       if args.first.is_a?(Hash)
@@ -25,17 +27,31 @@ class Typero
         opts[:type] ||= args[0]
       end
 
-      opts[:type]   ||= :string
-      opts[:required] = true unless opts[:required].is_a?(FalseClass) || opts[:req].is_a?(FalseClass)
+      opts[:type] = :string if opts[:type].nil?
 
       field = field.to_s
 
+      if field.include?('!')
+        if block
+          field = field.sub('!', '')
+          @block_type = field.to_sym
+          instance_exec &block
+          @block_type = nil
+          return
+        else
+          raise ArgumentError.new 'If you use ! you have to provide a block'
+        end
+      end
+
       # name? - opional name
       if field.include?('?')
         field = field.sub('?', '')
         opts[:required] = false
       end
 
+      opts[:required] = opts.delete(:req) unless opts[:req].nil?
+      opts[:required] = true if opts[:required].nil?
+
       # array that allows duplicates
       if opts[:type].is_a?(Array)
         opts[:type]  = opts[:type].first
@@ -48,20 +64,49 @@ class Typero
         opts[:array] = true
       end
 
+      opts[:type] = @block_type if @block_type
+
+      # Boolean
+      if opts[:type].is_a?(TrueClass) || opts[:type] == :true
+        opts[:required] = false
+        opts[:default]  = true
+        opts[:type]     = :boolean
+      elsif opts[:type].is_a?(FalseClass) || opts[:type] == :false || opts[:type] == :boolean
+        opts[:required] = false if opts[:required].nil?
+        opts[:default]  = false if opts[:default].nil?
+        opts[:type]     = :boolean
+      end
+
+      # model / schema
+      if opts[:type].class.ancestors.include?(Typero::Schema)
+        opts[:model] = opts.delete(:type)
+      end
+      opts[:model] = opts.delete(:schema) if opts[:schema]
+      opts[:type]  = :model if opts[:model]
+
+      if block_given?
+        opts[:type]  = :model
+        opts[:model] = Typero.schema &block
+      end
+
       opts[:type] ||= 'string'
-      opts[:type]   = opts[:type].to_s.downcase
+      opts[:type]   = opts[:type].to_s.downcase.to_sym
 
       opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
 
       # chek alloed params, all optional should go in meta
-      result = opts.keys - ALLOWED
-      raise ArgumentError.new('Unallowed Type params found: %s, allowed: %s' % [result.join(', '), ALLOWED]) if result.length > 0
+      opts.keys.each do |key|
+        type = Typero::Type.load opts[:type]
+        type.allowed_opt?(key) {|err| raise ArgumentError, err }
+      end
 
       field = field.to_sym
 
       db :add_index, field if opts.delete(:index)
 
-      klass = Typero::Type.load opts[:type]
+      # trigger error if type not found
+      Typero::Type.load opts[:type]
+
       @rules[field] = opts
     end
 
@@ -78,7 +123,7 @@ class Typero
     # set :emails, Array[:email]
     # email Array[:emails]
     def method_missing field, *args, &block
-      set field, *args
+      set field, *args, &block
     end
   end
 end

data/lib/typero/schema.rb

@@ -0,0 +1,165 @@
+module Typero
+  class Schema
+    SCHEMAS = {}
+    TYPES   = {}
+
+    # accepts dsl block to
+    def initialize &block
+      raise "Params not defined" unless block_given?
+      @schema = Params.new &block
+    end
+
+    # validates any instance object with hash variable interface
+    # it also coarces values
+    def validate object, options=nil
+      @options = options || {}
+      @object  = object
+      @errors  = {}
+
+      # remove undefined keys if Hash provided
+      if @options[:strict] && object.is_a?(Hash)
+        undefined = object.keys.map(&:to_s) - @schema.rules.keys.map(&:to_s)
+        object.delete_if { |k, _| undefined.include?(k.to_s) }
+      end
+
+      @schema.rules.each do |field, opts|
+        # force filed as a symbol
+        field = field.to_sym
+
+        for k in opts.keys
+          opts[k] = @object.instance_exec(&opts[k]) if opts[k].is_a?(Proc)
+        end
+
+        # set value to default if value is blank and default given
+        @object[field] = opts[:default] if opts[:default] && @object[field].blank?
+
+        if @object.respond_to?(:key?)
+          if @object.key?(field)
+            value = @object[field]
+          elsif @object.key?(field.to_s)
+            # invalid string key, needs fix
+            value = @object[field] = @object.delete(field.to_s)
+          end
+        else
+          value = @object[field]
+        end
+
+        if opts[:array]
+          unless value.respond_to?(:each)
+            opts[:delimiter] ||= /\s*[,\n]\s*/
+            value = value.to_s.split(opts[:delimiter])
+          end
+
+          value = value
+            .flatten
+            .map { |el| el.to_s == '' ? nil : check_filed_value(field, el, opts) }
+            .compact
+
+          value = Set.new(value).to_a unless opts[:duplicates]
+
+          opts[:max_count] ||= 100
+          add_error(field, 'Max number of array elements is %d, you have %d' % [opts[:max_count], value.length], opts) if value && value.length > opts[:max_count]
+          add_error(field, 'Min number of array elements is %d, you have %d' % [opts[:min_count], value.length], opts) if value && opts[:min_count] && value.length < opts[:min_count]
+
+          add_required_error field, value.first, opts
+        else
+          value = nil if value.to_s == ''
+
+          # if value is not list of allowed values, raise error
+          allowed = opts[:allow] || opts[:allowed] || opts[:values]
+          if value && allowed && !allowed.include?(value)
+            add_error field, 'Value "%s" is not allowed' % value, opts
+          end
+
+          value = check_filed_value field, value, opts
+          add_required_error field, value, opts
+        end
+
+        # present empty string values as nil
+        @object[field] = value.to_s.sub(/\s+/, '') == '' ? nil : value
+      end
+
+      if @errors.keys.length > 0 && block_given?
+        @errors.each { |k, v| yield(k, v) }
+      end
+
+      @errors
+    end
+
+    def valid? object
+      errors = validate object
+      errors.keys.length == 0
+    end
+
+    # returns field, db_type, db_opts
+    def db_schema
+      out = @schema.rules.inject([]) do |total, (field, opts)|
+        # get db filed schema
+        type, opts  = Typero::Type.load(opts[:type]).new(nil, opts).db_field
+
+        # add array true to field it ont defined in schema
+        schema_opts = @schema.rules[field]
+        opts[:array] = true if schema_opts[:array]
+
+        total << [type, field, opts]
+      end
+
+      out += @schema.db_rules
+
+      out
+    end
+
+    # iterate trough all the ruels via block interface
+    # schema.rules do |field, opts|
+    # schema.rules(:url) do |field, opts|
+    def rules filter = nil, &block
+      return @schema.rules unless filter
+      out = @schema.rules
+      out = out.select { |k, v| v[:type].to_s == filter.to_s || v[:array_type].to_s == filter.to_s } if filter
+      return out unless block_given?
+
+      out.each { |k, v| yield k, v }
+    end
+    alias :to_h :rules
+
+    private
+
+    # adds error to array or prefixes with field name
+    def add_error field, msg, opts
+      if @errors[field]
+        @errors[field] += ", %s" % msg
+      else
+        if msg && msg[0, 1].downcase == msg[0, 1]
+          field_name = opts[:name] || field.to_s.sub(/_id$/, "").capitalize
+          msg = "%s %s" % [field_name, msg]
+        end
+
+        @errors[field] = msg
+      end
+    end
+
+    def safe_type type
+      type.to_s.gsub(/[^\w]/, "").classify
+    end
+
+    def add_required_error field, value, opts
+      return unless opts[:required] && value.nil?
+      msg = opts[:required].class == TrueClass ? "is required" : opts[:required]
+      add_error field, msg, opts
+    end
+
+    def check_filed_value field, value, opts
+      klass = "Typero::%sType" % safe_type(opts[:type])
+      check = klass.constantize.new value, opts
+      check.get
+    rescue TypeError => e
+      if e.message[0] == '{'
+        for key, msg in JSON.parse(e.message)
+          add_error [field, key].join('.'), msg, opts
+        end
+      else
+        add_error field, e.message, opts
+      end
+    end
+  end
+end

data/lib/typero/type/type.rb

@@ -1,6 +1,6 @@
 # Master class
 
-class Typero
+module Typero
   class Type
     ERRORS = {
       en: {
@@ -9,14 +9,32 @@ class Typero
         max_length_error: 'max lenght is %s, you have %s',
         min_value_error: 'min is %s, got %s',
         max_value_error: 'max is %s, got %s',
-        unallowed_characters_error: 'is having unallowed characters'
+        unallowed_characters_error: 'is having unallowed characters',
+        not_in_range: 'Value in not in allowed range (%s)'
       }
     }
 
-    OPTS = {}
-
-    attr_accessor :opts
-    attr_accessor :value
+    # default shared allowed opts keys
+    OPTS      = {}
+    OPTS_KEYS = [
+      :allow,
+      :allowed,
+      :array,
+      :default,
+      :description,
+      :delimiter,
+      :max_count,
+      :meta,
+      :min_count,
+      :model,
+      :name,
+      :req,
+      :required,
+      :type,
+      :values
+    ]
+
+    attr_reader :opts
 
     class << self
       def load name
@@ -39,24 +57,64 @@ class Typero
         OPTS[self] ||= {}
         OPTS[self][key] = desc
       end
+
+      def allowed_opt? name
+        return true if OPTS_KEYS.include?(name)
+
+        OPTS[self] ||= {}
+        return true if OPTS[self][name]
+
+        msg  = %[Unallowed param "#{name}" for type "#{to_s}" found. Allowed are "#{OPTS_KEYS.join(', ')}"]
+        msg += %[ + "#{OPTS[self].keys.join(', ')}"] if OPTS[self].keys.first
+
+        block_given? ? yield(msg) : raise(ArgumentError, msg)
+
+        false
+      end
     end
 
     ###
 
-    def initialize value, opts={}
+    def initialize value, opts={}, &block
+      value = value.strip.rstrip if value.is_a?(String)
+
+      opts.keys.each {|key| self.class.allowed_opt?(key) }
+
       @value = value
       @opts  = opts
+      @block = block
+    end
+
+    def value &block
+      if block_given?
+        @value = block.call @value
+      else
+        @value
+      end
     end
 
-    # default validation for any type
-    def validate
-      true
+    def get
+      if value.nil?
+        opts[:default].nil? ? default : opts[:default]
+      else
+        set
+        error_for(:not_in_range, opts[:values].join(', ')) if opts[:values] && !opts[:values].include?(@value)
+        value
+      end
     end
 
     def default
       nil
     end
 
+    def db_field
+      out = db_schema
+      out[1] ||= {}
+      out[1][:default] ||= opts[:default] unless opts[:default].nil?
+      out[1][:null]      = false if !opts[:array] && opts[:required]
+      out
+    end
+
     private
 
     # get error from option or the default one