typero 0.3.6 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1c86d82e552055ef4caf2fcd72dcbfb040431d44f37dba36016ff93e4785ccf
-  data.tar.gz: d9e2dda55e722b7c7b2e6d54b87e363e7b1491c903007be100512cf22e0798f9
+  metadata.gz: e1b145b43e7736b2c9f673b6685388a39ee83fcba0bbcbc0ad2fcf8af2c1f692
+  data.tar.gz: dd730a85ab31d2b181b875d7052e3b109a263caba0618d869e262e3004e6d52f
 SHA512:
-  metadata.gz: ff912277d4fe41e6d18637ee208f2f91d066be02e4ef2b3fba26ce69684b13dcd5a9a8a1078d09b7e241b8c6196dccacdda6d06f1a2e08bc310c2f52d5ce9e6d
-  data.tar.gz: 5aa99ee889b1524727f43a76bf5c2cfd8b8d8f85a634081607248680f81dc0b004781bc1dff936b0a17d2a17e31bbe46536e52a569a7fc3f4cd2ea2c55d80cc4
+  metadata.gz: 86b7d2a84fccf9d800ae9c121773d3ae960b6f2c32100466836d6f07056ad2f2affa4fdbe8df8c91ea5cc208d7e006db993ddbce86c30b9652077b87f22cd4c5
+  data.tar.gz: 95a83f6b58874de8b27edb08811ea9543ebe7036550364d535f1a73042af90d77e36a891ccfcab9db36817572e6a400c203356cc54fb929358730bfc8425999e

data/.version

@@ -1 +1 @@
-0.3.6
+0.8.1

data/lib/adapters/sequel.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sequel::Plugins::TyperoAttributes
+  module ClassMethods
+    def typero
+      Typero.new 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)
+
+      typero = self.class.typero
+
+      typero.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'
+
+        # check uniqe fields
+        if rule[: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]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+
+        # check protected fields
+        if rule[:protected] && self[:id]
+          if column_changed?(field)
+            error = rule[:protected].class == TrueClass ? "value once defined can't be overwritten." : rule[:protected]
+            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
+
+  module DatasetMethods
+
+  end
+end
+
+Sequel::Model.plugin :typero_attributes
+

data/lib/typero.rb

@@ -1,164 +1,13 @@
-# rules = Typero.new do
-#   set :name, String, req: true
-#   set :email, :email, req: true
-#   set :skills, [:email], min: 2
-# end
-#
-# errors = rules.validate @object
-# rules.valid?
-# rules.validate(@object) { |errors| ... }
-
-class Typero
-  attr_reader :rules
-
-  VERSION = File.read File.expand_path '../.version', File.dirname(__FILE__)
-
-  class << self
-    # validate single value in type
-    def validate value, type, 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
-
-    # Typero.set(:label, 'Foo bar') -> "foo-bar"
-    def set type, value, opts={}
-      klass = 'Typero::%sType' % type.to_s.gsub(/[^\w]/,'').classify
-      check = klass.constantize.new value, opts
-      check.set
-    end
-
-    def cache
-      @@cache ||= {}
-    end
-  end
-
-  ###
-
-  # accepts dsl block to
-  def initialize hash={}, &block
-    @rules = {}
-    hash.each { |k, v| set(k, v) }
-    instance_exec &block if block
-  end
-
-  # convert
-  # integer :age
-  # set :age, type: :integer
-  # 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
-
-    set field, type=name, *args
-  end
-
-  # coerce opts values
-  def parse_option opts
-    opts[:type] ||= 'string'
-    opts[:req] = opts.delete(:required) unless opts[:required].nil?
-
-    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
-
-    allowed_names = [:req, :uniq, :protected, :type, :min, :max, :array_type, :default, :downcase, :desc]
-    opts.keys.each do |key|
-      raise ArgumentError.new('%s is not allowed as typero option' % key) unless allowed_names.index(key)
-    end
-
-    opts
-  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
-    klass = 'Typero::%sType' % opts[:type].to_s.gsub(/[^\w]/,'').classify
-    klass.constantize
-
-    @rules[field] = parse_option opts
-  end
-
-  def safe_type type
-    type.to_s.gsub(/[^\w]/,'').classify
-  end
-
-  # adds error to array or prefixes with field name
-  def add_error field, msg
-    if @errors[field]
-      @errors[field] += ', %s' % msg
-    else
-      field_name = field.to_s.sub(/_id$/,'').humanize
-      @errors[field] = '%s %s' % [field_name, msg]
-    end
-  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[:req]
-        msg = opts[:req].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
+# base libs
+require_relative 'typero/typero'
+require_relative 'typero/func'
+require_relative 'typero/params'
+require_relative 'typero/type/type'
+
+# checker types
+Dir['%s/typero/type/types/*.rb' % __dir__].each do |file|
+  require file
 end
 
-require_relative 'typero/type'
-
-Dir['%s/typero/type/*.rb' % File.dirname(__FILE__)].each { |file| require file }
+# load Sequel adapter is Sequel is available
+require_relative './adapters/sequel' if defined?(Sequel)

data/lib/typero/func.rb

@@ -0,0 +1,14 @@
+class Typero
+  SCHEMAS = {}
+end
+
+def Typero name=nil, &block
+  if block_given?
+    Typero.new(&block).tap do |schema|
+      Typero::SCHEMAS[name] = schema if name
+    end
+  else
+    raise ArgumentErorr.new('Schema nema not given') unless name
+    Typero::SCHEMAS[name] || raise(ArgumentErorr.new('Typero schema "%s" not defined' % name))
+  end
+end

data/lib/typero/params.rb

@@ -0,0 +1,84 @@
+# Base class for schema validation
+
+class 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
+
+    def initialize &block
+      @db_rules = []
+      @rules    = {}
+      instance_exec &block
+    end
+
+    private
+
+    # used in dsl to define schema field options
+    def set field, *args
+      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
+      opts[:required] = true unless opts[:required].is_a?(FalseClass) || opts[:req].is_a?(FalseClass)
+
+      field = field.to_s
+
+      # name? - opional name
+      if field.include?('?')
+        field = field.sub('?', '')
+        opts[:required] = false
+      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] ||= 'string'
+      opts[:type]   = opts[:type].to_s.downcase
+
+      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
+
+      field = field.to_sym
+
+      db :add_index, field if opts.delete(:index)
+
+      klass = 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
+    end
+  end
+end

data/lib/typero/type/type.rb

@@ -0,0 +1,82 @@
+# Master class
+
+class Typero
+  class Type
+    ERRORS = {
+      en: {
+        # errors shared between various types
+        min_length_error: 'min lenght is %s, you have %s',
+        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'
+      }
+    }
+
+    OPTS = {}
+
+    attr_accessor :opts
+    attr_accessor :value
+
+    class << self
+      def load name
+        klass = 'Typero::%sType' % name.to_s.gsub(/[^\w]/,'').classify
+
+        if const_defined? klass
+          klass.constantize
+        else
+          raise ArgumentError, 'Typero type "%s" is not defined (%s)' % [name, klass]
+        end
+      end
+
+      def error locale, key, message
+        locale = locale.to_sym
+        ERRORS[locale] ||= {}
+        ERRORS[locale][key.to_sym] = message
+      end
+
+      def opts key, desc
+        OPTS[self] ||= {}
+        OPTS[self][key] = desc
+      end
+    end
+
+    ###
+
+    def initialize value, opts={}
+      @value = value
+      @opts  = opts
+    end
+
+    # default validation for any type
+    def validate
+      true
+    end
+
+    def default
+      nil
+    end
+
+    private
+
+    # get error from option or the default one
+    def error_for name, *args
+      locale =
+      if defined?(Lux)
+        Lux.current.locale.to_s
+      elsif defined?(I18n)
+        I18n.locale
+      end
+
+      locale  = :en if locale.to_s == ''
+      pointer = ERRORS[locale.to_sym] || ERRORS[:en]
+      error   = @opts.dig(:meta, locale, name) || @opts.dig(:meta, name) || pointer[name]
+      error   = error % args if args.first
+
+      raise 'Type error :%s not defined' % name unless error
+      raise TypeError.new(error)
+    end
+  end
+end
+
+

data/lib/typero/type/{boolean.rb → types/boolean.rb}

@@ -6,5 +6,11 @@ class Typero::BooleanType < Typero::Type
   def set
     @value = [true, 1, '1', 'true', 'on'].include?(@value) ? true : false
   end
+
+  def db_field
+    opts = {}
+    opts[:default]  = @opts[:default] || false
+    [:boolean, opts]
+  end
 end
 

data/lib/typero/type/types/currency.rb

@@ -0,0 +1,19 @@
+# you should not use this filed for currency calculations
+
+require_relative './float'
+
+class Typero::CurrencyType < Typero::FloatType
+
+  def set
+    @value = @value.to_f.round(2)
+  end
+
+  def db_field
+    opts = {}
+    opts[:precision] = 8
+    opts[:scale]     = 2
+    [:decimal, opts]
+  end
+
+end
+

data/lib/typero/type/types/date.rb

@@ -0,0 +1,10 @@
+class Typero::DateType < Typero::Type
+  def set
+    @value = @value.to_s.downcase.gsub(/[^\d\-\.\s]/, '')
+  end
+
+  def db_field
+    [:date, {}]
+  end
+end
+

data/lib/typero/type/types/datetime.rb

@@ -0,0 +1,10 @@
+class Typero::DatetimeType < Typero::Type
+  def set
+    @value = @value.to_s.downcase.gsub(/[^\d\-\.\s\:]/, '')
+  end
+
+  def db_field
+    [:datetime, {}]
+  end
+end
+

data/lib/typero/type/types/email.rb

@@ -0,0 +1,21 @@
+class Typero::EmailType < Typero::Type
+  error :en, :not_8_chars_error, 'is not having at least 8 characters'
+  error :en, :missing_monkey_error, 'is missing @'
+
+  def set
+    @value = @value.downcase.gsub(/\s+/,'+')
+  end
+
+  def validate
+    error_for(:not_8_chars_error) unless @value.to_s.length > 7
+    error_for(:missing_monkey_error) unless @value.include?('@')
+  end
+
+  def db_field
+    opts = {}
+    opts[:limit] = @opts[:max] || 120
+    opts[:null]  = false if @opts[:required]
+    [:string, opts]
+  end
+end
+

data/lib/typero/type/types/float.rb

@@ -0,0 +1,21 @@
+class Typero::FloatType < Typero::Type
+  opts :min, 'Minimum value'
+  opts :max, 'Maximun value'
+
+  def set
+    @value = @value.to_f
+  end
+
+  def validate
+    error_for(:min_length_error, @opts[:min], @value) if @opts[:min] && value < @opts[:min]
+    error_for(:max_length_error, @opts[:max], @value) if @opts[:max] && value > @opts[:max]
+  end
+
+  def db_field
+    opts = {}
+    opts[:null] = false if @opts[:required]
+    [:float, opts]
+  end
+
+end
+

data/lib/typero/type/types/hash.rb

@@ -0,0 +1,22 @@
+class Typero::HashType < Typero::Type
+  error :en, :not_hash_type_error, 'value is not hash type'
+
+  def default
+    {}
+  end
+
+  def set
+    @value = @value.to_h
+  end
+
+  def validate
+    error_for(:not_hash_type_error) unless @value.is_a?(Hash)
+  end
+
+  def db_field
+    [:jsonb, {
+      null: false
+    }]
+  end
+end
+

data/lib/typero/type/types/image.rb

@@ -0,0 +1,28 @@
+class Typero::ImageType < Typero::Type
+  FORMATS = %w[jpg jpeg gif png svg webp]
+
+  error :en, :image_not_starting_error, 'URL is not starting with http'
+  error :en, :image_not_image_format, 'URL is not ending with %s' % FORMATS.join(', ')
+
+  opts :strict, 'Force image to have known extension (%s)' % FORMATS.join(', ')
+
+  def set
+    @value = 'https://%s' % @value unless @value.include?('://')
+  end
+
+  def validate
+    error_for(:image_not_starting_error) unless @value =~ /^https?:\/\/./
+
+    if opts[:strict]
+      ext = @value.split('.').last.downcase
+      error_for(:image_not_image_format) unless FORMATS.include?(ext)
+    end
+  end
+
+  def db_field
+    opts = {}
+    opts[:null] = false if @opts[:required]
+    [:string, opts]
+  end
+end
+

data/lib/typero/type/types/integer.rb

@@ -0,0 +1,21 @@
+class Typero::IntegerType < Typero::Type
+  opts :min, 'Minimum value'
+  opts :max, 'Maximun value'
+
+  def set
+    @value = @value.to_i
+  end
+
+  def validate
+    error_for(:min_value_error, @opts[:min], @value) if @opts[:min] && @value < @opts[:min]
+    error_for(:max_value_error, @opts[:max], @value) if @opts[:max] && @value > @opts[:max]
+  end
+
+  def db_field
+    opts = {}
+    opts[:null]    = false if @opts[:required]
+    opts[:default] = @opts[:default]
+    [:integer, opts]
+  end
+end
+

data/lib/typero/type/{label.rb → types/label.rb}

@@ -4,6 +4,12 @@ class Typero::LabelType < Typero::Type
   end
 
   def validate
-    raise TypeError, "Label is having unallowed characters" unless @value =~ /^[\w\-]+$/
+    error_for(:unallowed_characters_error) unless @value =~ /^[\w\-]+$/
+  end
+
+  def db_field
+    opts = {}
+    opts[:limit]   = 30
+    [:string, opts]
   end
 end

data/lib/typero/type/types/oib.rb

@@ -0,0 +1,42 @@
+class Typero::OibType < Typero::Type
+  error :en, :not_an_oib_error, 'not in an OIB format'
+
+  def set
+    @value = check?(@value) ? @value.to_i : nil
+  end
+
+  def validate
+    error_for(:not_an_oib_error) unless check?(@value)
+  end
+
+  def db_field
+    opts = {}
+    opts[:null]  = false if @opts[:required]
+    opts[:limit] = 11
+    [:string, opts]
+  end
+
+  private
+
+  # http://domagoj.eu/oib/
+  def check? oib
+    oib = oib.to_s
+
+    return false unless oib.match(/^[0-9]{11}$/)
+
+    control_sum = (0..9).inject(10) do |middle, position|
+      middle += oib.at(position).to_i
+      middle %= 10
+      middle = 10 if middle == 0
+      middle *= 2
+      middle %= 11
+    end
+
+    control_sum = 11 - control_sum
+    control_sum = 0 if control_sum == 10
+
+    return control_sum == oib.at(10).to_i
+  end
+
+end
+

data/lib/typero/type/types/point.rb

@@ -0,0 +1,29 @@
+# for postgres - select st_asewkt(lon_lat) || st_astext(lon_lat)
+# point = @object.class.xselect("ST_AsText(#{field}) as #{field}").where(id: @object.id).first[field.to_sym]
+
+class Typero::PointType < Typero::Type
+  def set
+    if @value.present?
+      if @value.include?('/@')
+        point = @value.split('/@', 2).last.split(',')
+        @value = [point[0], point[1]].join(',')
+      end
+
+      if !@value.include?('POINT') && @value.include?(',')
+        point = @value.sub(/,\s*/, ' ')
+        @value = 'SRID=4326;POINT(%s)' % point
+      end
+    end
+  end
+
+  def validate
+    if @value && @value.include?(',') && !@value =~ /^SRID=4326;POINT\(/
+      error_for(:unallowed_characters_error)
+    end
+  end
+
+  def db_field
+    [:geography, {}]
+  end
+end
+

data/lib/typero/type/types/string.rb

@@ -0,0 +1,23 @@
+class Typero::StringType < Typero::Type
+  opts :min, 'Minimun string length'
+  opts :max, 'Maximun string length'
+
+  def set
+    @value = @value.to_s unless @value.is_a?(String)
+    @value = @value.downcase if @opts[:downcase]
+  end
+
+  def validate
+    error_for(:min_length_error, @opts[:min], @value.length) if @opts[:min] && @value.length < @opts[:min]
+    error_for(:max_length_error, @opts[:max], @value.length) if @opts[:max] && @value.length > @opts[:max]
+  end
+
+  def db_field
+    opts = {}
+    opts[:limit]   = @opts[:max] || 255
+    opts[:null]    = false if @opts[:required]
+    opts[:default] = @opts[:default]
+    [:string, opts]
+  end
+end
+

data/lib/typero/type/types/text.rb

@@ -0,0 +1,12 @@
+require_relative 'string'
+
+class Typero::TextType < Typero::StringType
+  opts :min, 'Minimun string length'
+  opts :max, 'Maximun string length'
+
+  def db_field
+    opts = {}
+    opts[:null]  = false if @opts[:required]
+    [:text, opts]
+  end
+end

data/lib/typero/type/types/url.rb

@@ -0,0 +1,18 @@
+class Typero::UrlType < Typero::Type
+  error :en, :url_not_starting_error, 'URL is not starting with http'
+
+  def set
+    @value = 'http://%s' % @value unless @value.include?('://')
+  end
+
+  def validate
+    error_for(:url_not_starting_error) unless @value =~ /^https?:\/\/./
+  end
+
+  def db_field
+    opts = {}
+    opts[:null] = false if @opts[:required]
+    [:string, opts]
+  end
+end
+

data/lib/typero/typero.rb

@@ -0,0 +1,177 @@
+# 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| ... }
+
+class Typero
+  VERSION = File.read File.expand_path "../../.version", File.dirname(__FILE__)
+
+  class << self
+    # check and coerce value
+    # Typero.set(:label, 'Foo bar') -> "foo-bar"
+    def set type, value, opts = {}, &block
+      check = Typero::Type.load(type).new value, opts
+      check.set
+      check.validate
+      check.value
+    rescue TypeError => error
+      if block
+        block.call error
+        false
+      else
+        raise error
+      end
+    end
+  end
+
+  ###
+
+  # 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
+    @object = object
+    @errors = {}
+
+    @schema.rules.each do |field, opts|
+      # 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.is_a?(Array)
+          opts[:delimiter] ||= /\s*,\s*/
+          value = value.to_s.split(opts[:delimiter])
+        end
+
+        value = value
+          .map { |el| check_filed_value field, el, opts }
+          .map { |el| el.to_s == '' ? nil : el }
+          .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.length > opts[:max_count]
+
+        check_required field, value.first, opts
+      else
+        value = check_filed_value field, value, opts
+          check_required field, value, opts
+      end
+
+      # if value is not list of allowed values, raise error
+      if opts[:allowed] && !opts[:values].include?(value)
+        add_error field, 'Value "%s" is not allowed' % 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
+
+  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$/, "").humanize
+        msg = "%s %s" % [field_name, msg]
+      end
+
+      @errors[field] = msg
+    end
+  end
+
+  def safe_type type
+    type.to_s.gsub(/[^\w]/, "").classify
+  end
+
+  def check_required field, value, opts
+    return if !opts[:required] || value
+    msg = opts[:required].class == TrueClass ? "is required" : opts[:required]
+    add_error field, msg, opts
+  end
+
+  def check_filed_value field, value, opts
+    return unless value
+
+    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
+        check.value
+      rescue TypeError => e
+        add_error field, e.message, opts
+      end
+    end
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.8.1
 platform: ruby
 authors:
 - Dino Reic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-06 00:00:00.000000000 Z
+date: 2020-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 description: Simple and fast ruby type system. Enforce types as Array, Email, Boolean
   for ruby class instances
 email: reic.dino@gmail.com
@@ -32,18 +32,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - "./.version"
+- "./lib/adapters/sequel.rb"
 - "./lib/typero.rb"
-- "./lib/typero/type.rb"
-- "./lib/typero/type/array.rb"
-- "./lib/typero/type/boolean.rb"
-- "./lib/typero/type/email.rb"
-- "./lib/typero/type/float.rb"
-- "./lib/typero/type/hash.rb"
-- "./lib/typero/type/integer.rb"
-- "./lib/typero/type/label.rb"
-- "./lib/typero/type/oib.rb"
-- "./lib/typero/type/string.rb"
-- "./lib/typero/type/url.rb"
+- "./lib/typero/func.rb"
+- "./lib/typero/params.rb"
+- "./lib/typero/type/type.rb"
+- "./lib/typero/type/types/boolean.rb"
+- "./lib/typero/type/types/currency.rb"
+- "./lib/typero/type/types/date.rb"
+- "./lib/typero/type/types/datetime.rb"
+- "./lib/typero/type/types/email.rb"
+- "./lib/typero/type/types/float.rb"
+- "./lib/typero/type/types/hash.rb"
+- "./lib/typero/type/types/image.rb"
+- "./lib/typero/type/types/integer.rb"
+- "./lib/typero/type/types/label.rb"
+- "./lib/typero/type/types/oib.rb"
+- "./lib/typero/type/types/point.rb"
+- "./lib/typero/type/types/string.rb"
+- "./lib/typero/type/types/text.rb"
+- "./lib/typero/type/types/url.rb"
+- "./lib/typero/typero.rb"
 homepage: https://github.com/dux/typero
 licenses:
 - MIT
@@ -63,8 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.5
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ruby type system

data/lib/typero/type.rb

@@ -1,28 +0,0 @@
-class Typero::Type
-  attr_accessor :opts
-  attr_accessor :value
-
-  def initialize(value, opts={})
-    @value = value
-    @opts  = opts
-  end
-
-  # default validation for any type
-  def validate(what)
-    true
-  end
-
-  def get
-    @value
-  end
-
-  def set
-    @value
-  end
-
-  def default
-    nil
-  end
-end
-
-

data/lib/typero/type/array.rb

@@ -1,32 +0,0 @@
-class Typero::ArrayType < Typero::Type
-  def default
-    []
-  end
-
-  def set
-    unless @value.class.to_s.index('Array')
-      @value = @value.to_s.sub(/^\{/,'').sub(/\}$/,'').split(/\s*,\s*/)
-    end
-
-    @value.uniq!
-    @value.compact!
-
-    if type = @opts[:array_type]
-      @value.map! { |el|
-        Typero.validate(el, type) { |msg|
-          raise TypeError.new "'%s' %s (value in list)" % [el, msg]
-        }
-      }
-    end
-
-    # this converts Sequel::Postgres::PGArray to Array and fixes many problems
-    @value = @value.to_a if @value.class != Array
-  end
-
-  def validate
-    raise TypeError, 'Min array lenght is %s elements' % @opts[:min] if @opts[:min] && @value.length < @opts[:min]
-    raise TypeError, 'Max array lenght is %s elements' % @opts[:max] if @opts[:max] && @value.length > @opts[:max]
-    true
-  end
-end
-

data/lib/typero/type/email.rb

@@ -1,14 +0,0 @@
-class Typero::EmailType < Typero::Type
-
-  def set
-    @value = @value.downcase.gsub(/\s+/,'+')
-  end
-
-  def validate
-    raise TypeError, 'is not having at least 8 characters' unless @value.to_s.length > 7
-    raise TypeError, 'is missing @' unless @value.include?('@')
-    # raise TypeError, "[#{@value}] is in wrong format" unless @value =~ /^[\+\w\-\.]+\@[\w\-\.]+$/i
-  end
-
-end
-

data/lib/typero/type/float.rb

@@ -1,13 +0,0 @@
-class Typero::FloatType < Typero::Type
-
-  def set
-    @value = @value.to_f
-  end
-
-  def validate
-    raise TypeError, "min lenght is #{@opts[:min]}" if @opts[:min] && value < @opts[:min]
-    raise TypeError, "max lenght is #{@opts[:max]}" if @opts[:max] && value > @opts[:max]
-  end
-
-end
-

data/lib/typero/type/hash.rb

@@ -1,10 +0,0 @@
-class Typero::HashType < Typero::Type
-  def default
-    {}
-  end
-
-  def validate
-    raise TypeError, 'Value is not hash type' unless @value.is_a?(Hash)
-  end
-end
-

data/lib/typero/type/integer.rb

@@ -1,11 +0,0 @@
-class Typero::IntegerType < Typero::Type
-  def set
-    @value = @value.to_i
-  end
-
-  def validate
-    raise TypeError, 'min is %s, got %s' % [@opts[:min], @value] if @opts[:min] && @value < @opts[:min]
-    raise TypeError, 'max is %s, got %s' % [@opts[:max], @value] if @opts[:max] && @value > @opts[:max]
-  end
-end
-

data/lib/typero/type/oib.rb

@@ -1,29 +0,0 @@
-class Typero::OibType < Typero::Type
-  def check? oib
-    oib = oib.to_s
-
-    return false if (oib =~ /\d{11}/) != 0
-    return false if oib.length != 11
-
-    a = 10
-    (0..9).each do |i|
-      a = (a + oib[i,1].to_i) % 10
-      a = 10 if a == 0
-      a = (a * 2) % 11
-    end
-
-    kontrolna = 11 - a
-    kontrolna = 0 if kontrolna == 10
-
-    kontrolna == oib[10,1].to_i
-  end
-
-  def set
-    @value = check?(@value) ? @value.to_i : nil
-  end
-
-  def validate
-    raise TypeError.new('Not an OIB') unless check?(@value)
-  end
-end
-

data/lib/typero/type/string.rb

@@ -1,12 +0,0 @@
-class Typero::StringType < Typero::Type
-  def set
-    @value = @value.to_s unless @value.is_a?(String)
-    @value = @value.downcase if @opts[:downcase]
-  end
-
-  def validate
-    raise TypeError, 'min lenght is %s, you have %s' % [@opts[:min], @value.length] if @opts[:min] && @value.length < @opts[:min]
-    raise TypeError, 'max lenght is %s, you have %s' % [@opts[:max], @value.length] if @opts[:max] && @value.length > @opts[:max]
-  end
-end
-

data/lib/typero/type/url.rb

@@ -1,10 +0,0 @@
-class Typero::UrlType < Typero::Type
-  def set
-    @value = 'http://%s' % @value unless @value.include?('://')
-  end
-
-  def validate
-    raise TypeError, 'URL is not starting with http' unless @value =~ /^https?:\/\/./
-  end
-end
-