typero 0.5.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3abfc7ee1372098804789576ac4fb36dbfb33a2cce2e48cd2dda70b975a2a1f6
-  data.tar.gz: 9ed9618bde6dd268b39f516428c63c07a3aa86006323a0dd0b231a421e6a4c68
+  metadata.gz: 2b0ee2233c2ba484ec5ff98778a8da24a876b7b22eb4d24cc6b3ba3a8886e714
+  data.tar.gz: 4a96d10f9c6d0e75e8ae36965d34a6cda8853684974f799e2cf5e32d6a7003c1
 SHA512:
-  metadata.gz: 3ab235a93802052f17166cf1bda8a3cd75ee20def1c669c9b5ccf7bb4d7633ae2ddffec6cc01f57e3bf2c98aaf652731a1deb7c2450e658da76ae8092e3790a1
-  data.tar.gz: 4430507594bdecbb95aff494ed0e8dc1a71d22111abecafec19a801d3d4445d1a32dfe5fd861b330515d7b63ba0a9867d53e088e1c2a3d206b13cf9147a09cd1
+  metadata.gz: 880c3e4e551ab660f85530454ad9007ae383118677ea209ffaf0efff54bcd38da220579dc42d87618bd9ea50790b04a46c63dfe3cfd6252508b2bbec6ba1d711
+  data.tar.gz: 6f10437b894c91f3c7f723da03b426218d60b21c8bd161111d8ae7a745bdf35565f4fba84f26552fc75aa9b40211f3902d1cc2418fc420a5e3bce912ac676bc2

data/.version

@@ -1 +1 @@
-0.5.2
+0.9.3

data/lib/adapters/sequel.rb

@@ -1,67 +1,45 @@
 # frozen_string_literal: true
 
-require 'typero'
-
 module Sequel::Plugins::TyperoAttributes
   module ClassMethods
-    def attributes opts={}, &block
-      instance_variable_set :@typero, Typero.new(&block)
-
-      # attributes migrate: true do ...
-      AutoMigrate.typero to_s.tableize.to_sym if opts[:migrate] && Lux.config.migrate
-    end
-
     def typero
-      instance_variable_get :@typero
+      Typero.schema self
     end
   end
 
   module InstanceMethods
     # calling typero! on any object will validate all fields
-    def typero! field_name=nil
-      typero = self.class.typero || return
+    def validate
+      super
 
-      typero.validate(self) do |name, err|
+      schema = Typero.schema(self.class) || return
+
+      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|
+      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} allready exists] : 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,194 +1,13 @@
-# rules = Typero.new do
-#   set :name, String, req: true
-#   set :email, :email, req: true
-#   set :skills, [:email], min: 2
-# end
-#
-# or
-#
-# rules = Typero.new do
-#   string :name, req: true
-#   email :email, req: true
-#   email [:skills], min: 2
-# end
-#
-# errors = rules.validate @object
-# rules.valid?
-# rules.validate(@object) { |errors| ... }
+# require 'hash_wia'
 
-class Typero
-  attr_reader :rules
+# base libs
+require_relative 'typero/typero'
+require_relative 'typero/schema'
+require_relative 'typero/params'
+require_relative 'typero/type/type'
 
-  VERSION = File.read File.expand_path '../.version', File.dirname(__FILE__)
-
-  class << self
-    # validate single value in type
-    def validate type, value, opts={}
-      field = type.to_s.tableize.singularize.to_sym
-
-      # we need to have pointer to hash, so value can be changed (coerced) if needed
-      h = { field => value }
-
-      rule = new
-      rule.set field, type, opts
-
-      if error = rule.validate(h)[field]
-        block_given? ? yield(error) : raise(TypeError.new(error))
-      end
-
-      h[field]
-    end
-
-    # check and coerce value
-    # Typero.set(:label, 'Foo bar') -> "foo-bar"
-    def set type, value, opts={}
-      check = Typero::Type.load(type).new value, opts
-      check.value
-    end
-  end
-
-  ###
-
-  # accepts dsl block to
-  def initialize hash={}, &block
-    @rules = {}
-    @db    = []
-    hash.each { |k, v| set(k, v) }
-    instance_exec &block if block
-  end
-
-  # validates any instance object or object with hash variable interface
-  # it also coarces values
-  def validate instance
-    @errors = {}
-
-    @rules.each do |field, opts|
-      # set value to default if value is blank and default given
-      instance[field] = opts[:default] if opts[:default] && instance[field].blank?
-
-      # get field value
-      value = instance[field]
-
-      if value.present?
-        klass = 'Typero::%sType' % safe_type(opts[:type])
-        check = klass.constantize.new value, opts
-        check.value = check.default if check.value.nil?
-
-        unless check.value.nil?
-          begin
-            check.set
-            check.validate
-            instance[field] = check.value
-          rescue TypeError => e
-            add_error field, e.message
-          end
-        end
-      elsif opts[:required]
-        msg = opts[:required].class == TrueClass ? 'is required' : opts[:req]
-        add_error field, msg
-      end
-    end
-
-    if @errors.keys.length > 0 && block_given?
-      @errors.each { |k,v| yield(k, v) }
-    end
-
-    @errors
-  end
-
-  def valid? instance
-    errors = validate instance
-    errors.keys.length == 0
-  end
-
-  # returns field, db_type, db_opts
-  def db_schema
-    out = @rules.inject([]) do |total, (field, opts)|
-      type, opts = Typero::Type.load(opts[:type]).new(nil, opts).db_field
-      total << [type, field, opts]
-    end
-
-    out += @db if @db[0]
-
-    out
-  end
-
-  private
-
-  # adds error to array or prefixes with field name
-  def add_error field, msg
-    if @errors[field]
-      @errors[field] += ', %s' % msg
-    else
-      if msg[0,1].downcase == msg[0,1]
-        field_name = field.to_s.sub(/_id$/,'').humanize
-        msg = '%s %s' % [field_name, msg]
-      end
-
-      @errors[field] = msg
-    end
-  end
-
-  # used in dsl to define value
-  def set field, type=String, opts={}
-    opts = type.is_a?(Hash) ? type : opts.merge(type: type)
-    opts[:type] ||= :string
-    opts[:req]    = true if opts[:null].class == FalseClass
-    klass = Typero::Type.load opts[:type]
-    @rules[field] = parse_option opts
-  end
-
-  def safe_type type
-    type.to_s.gsub(/[^\w]/,'').classify
-  end
-
-  # coerce opts values
-  def parse_option opts
-    opts[:type] ||= 'string'
-
-    if opts[:type].is_a?(Array)
-       opts[:array_type] = opts[:type][0] if opts[:type][0]
-       opts[:type] = 'array'
-    end
-
-    opts[:type] = opts[:type].to_s.downcase
-
-    opts[:required]    = opts.delete(:req)  unless opts[:req].nil?
-    opts[:unique]      = opts.delete(:uniq) unless opts[:uniq].nil?
-    opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
-
-    opts
-  end
-
-
-  # pass values for db_schema only
-  # db :timestamps
-  # db :add_index, :code -> t.add_index :code
-  def db *args
-    @db.push args
-  end
-
-  # set :age, type: :integer -> integer :age
-  # email :email
-  # set :email, [:emails]
-  # email [:emails]
-  def method_missing name, *args, &block
-    field = args.shift
-
-    if field.class == Array
-      field = field.first
-      name  = [name]
-    end
-
-    name = args.shift if name == :set
-
-    set field, type=name, *args
-  end
-end
-
-require_relative 'typero/type'
-
-Dir['%s/typero/type/*.rb' % __dir__].each do |file|
+# checker types
+Dir['%s/typero/type/types/*.rb' % __dir__].each do |file|
   require file
 end
 

data/lib/typero/params.rb

@@ -0,0 +1,126 @@
+# Base class for schema validation
+
+module Typero
+  class Params
+    attr_reader :db_rules
+
+    def initialize &block
+      @db_rules = []
+      @rules    = {}
+      instance_exec &block
+    end
+
+    def rules
+      @rules.dup
+    end
+
+    private
+
+    # used in dsl to define schema field options
+    def set field, *args, &block
+      raise "Field name not given (Typero)" unless field
+
+      if args.first.is_a?(Hash)
+        opts = args.first || {}
+      else
+        opts = args[1] || {}
+        opts[:type] ||= args[0]
+      end
+
+      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
+
+      if value = opts.delete(:req)
+        opts[:required] = value
+      else
+        opts[:required] = true if opts[:required].nil?
+      end
+
+      # array that allows duplicates
+      if opts[:type].is_a?(Array)
+        opts[:type]  = opts[:type].first
+        opts[:array] = true
+      end
+
+      # no duplicates array
+      if opts[:type].is_a?(Set)
+        opts[:type]  = opts[:type].to_a.first
+        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[:required] = false
+        opts[:default]  = false
+        opts[:type]     = :boolean
+      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.to_sym
+
+      opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
+
+      # chek alloed params, all optional should go in meta
+      result = opts.keys - Typero::Type::OPTS_KEYS
+      raise ArgumentError.new('Unallowed Type params found: "%s", allowed: %s' % [result.join(' and '), Typero::Type::OPTS_KEYS.sort]) if result.length > 0
+
+      field = field.to_sym
+
+      db :add_index, field if opts.delete(:index)
+
+      # trigger error if type not found
+      Typero::Type.load opts[:type]
+
+      @rules[field] = opts
+    end
+
+    # pass values for db_schema only
+    # db :timestamps
+    # db :add_index, :code -> t.add_index :code
+    def db *args
+      @db_rules.push args
+    end
+
+    # set :age, type: :integer -> integer :age
+    # email :email
+    #
+    # set :emails, Array[:email]
+    # email Array[:emails]
+    def method_missing field, *args, &block
+      set field, *args, &block
+    end
+  end
+end

data/lib/typero/schema.rb

@@ -0,0 +1,154 @@
+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|
+        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?
+
+        # get field value
+        value = @object[field]
+
+        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