typero 0.9.0 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e78c338c182793ab2bffd1b4c5469d5285f57f55697402b6e80fb1881a3f7a8
-  data.tar.gz: 18a803b38ef8a24cb3756a43e5b5704082a08f4d805be57239cb054c28e6f132
+  metadata.gz: 2b0ee2233c2ba484ec5ff98778a8da24a876b7b22eb4d24cc6b3ba3a8886e714
+  data.tar.gz: 4a96d10f9c6d0e75e8ae36965d34a6cda8853684974f799e2cf5e32d6a7003c1
 SHA512:
-  metadata.gz: 1c02d8cec42f465c5cf34b0b69c856cf193f1c5e289898af0aefdebf1d61ed91c95148a1fa9ca1c047a07810c99bd518946dbfe323e0e53c4502b66b08910c85
-  data.tar.gz: de185fca3ac80a4e7e9d6b87778872b3b352f89678f334e24b0047480d401cbd0abf95bb8940ba0e29d9d3f485ef62521b38335f1f6cc3a7d1f59194383f4a67
+  metadata.gz: 880c3e4e551ab660f85530454ad9007ae383118677ea209ffaf0efff54bcd38da220579dc42d87618bd9ea50790b04a46c63dfe3cfd6252508b2bbec6ba1d711
+  data.tar.gz: 6f10437b894c91f3c7f723da03b426218d60b21c8bd161111d8ae7a745bdf35565f4fba84f26552fc75aa9b40211f3902d1cc2418fc420a5e3bce912ac676bc2

data/.version

@@ -1 +1 @@
-0.9.0
+0.9.3

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} 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,8 +1,9 @@
+# require 'hash_wia'
+
 # base libs
 require_relative 'typero/typero'
 require_relative 'typero/schema'
 require_relative 'typero/params'
-require_relative 'typero/exporter'
 require_relative 'typero/type/type'
 
 # checker types

data/lib/typero/params.rb

@@ -2,7 +2,7 @@
 
 module Typero
   class Params
-    attr_reader :rules, :db_rules
+    attr_reader :db_rules
 
     def initialize &block
       @db_rules = []
@@ -10,10 +10,14 @@ module 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)
@@ -27,13 +31,29 @@ module Typero
 
       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] = true if opts[:required].nil?
+      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)
@@ -47,12 +67,14 @@ module Typero
         opts[:array] = true
       end
 
+      opts[:type] = @block_type if @block_type
+
       # Boolean
-      if opts[:type].is_a?(TrueClass)
+      if opts[:type].is_a?(TrueClass) || opts[:type] == :true
         opts[:required] = false
         opts[:default]  = true
         opts[:type]     = :boolean
-      elsif opts[:type].is_a?(FalseClass)
+      elsif opts[:type].is_a?(FalseClass) || opts[:type] == :false
         opts[:required] = false
         opts[:default]  = false
         opts[:type]     = :boolean
@@ -61,6 +83,11 @@ module Typero
       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
 
@@ -93,7 +120,7 @@ module 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

@@ -1,6 +1,7 @@
 module Typero
   class Schema
     SCHEMAS = {}
+    TYPES   = {}
 
     # accepts dsl block to
     def initialize &block
@@ -10,11 +11,22 @@ module Typero
 
     # validates any instance object with hash variable interface
     # it also coarces values
-    def validate object
-      @object = object
-      @errors = {}
+    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?
 
@@ -22,32 +34,36 @@ module Typero
         value = @object[field]
 
         if opts[:array]
-          unless value.is_a?(Array)
-            opts[:delimiter] ||= /\s*,\s*/
+          unless value.respond_to?(:each)
+            opts[:delimiter] ||= /\s*[,\n]\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 }
+            .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.length > opts[:max_count]
+          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
 
-        # 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
@@ -126,7 +142,13 @@ module Typero
       check = klass.constantize.new value, opts
       check.get
     rescue TypeError => e
-      add_error field, e.message, opts
+      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

@@ -15,8 +15,23 @@ module Typero
     }
 
     # default shared allowed opts keys
-    OPTS_KEYS = [:type, :required, :array, :max_count, :default, :name, :meta, :model]
     OPTS      = {}
+    OPTS_KEYS = [
+      :allow,
+      :allowed,
+      :array,
+      :default,
+      :description,
+      :max_count,
+      :meta,
+      :min_count,
+      :model,
+      :name,
+      :req,
+      :required,
+      :type,
+      :values
+    ]
 
     attr_reader :opts
 
@@ -48,7 +63,7 @@ module Typero
     ###
 
     def initialize value, opts={}, &block
-      value = value.sub(/^\s+/, '').sub(/\s+$/, '') if value.is_a?(String)
+      value = value.strip.rstrip if value.is_a?(String)
 
       @value = value
       @opts  = opts

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

@@ -3,7 +3,10 @@ class Typero::DateType < Typero::Type
   error :en, :max_date, 'Maximal allowed date is %s'
 
   def set
-    value { |data| DateTime.parse(data) }
+    unless [Date].include?(value.class)
+      value { |data| DateTime.parse(data) }
+    end
+
     value { |data| DateTime.new(data.year, data.month, data.day) }
 
     check_date_min_max

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

@@ -2,7 +2,9 @@ require_relative 'date_type'
 
 class Typero::DatetimeType < Typero::DateType
   def set
-    value { |data| DateTime.parse(data) }
+    unless [Time, DateTime].include?(value.class)
+      value { |data| DateTime.parse(data) }
+    end
 
     check_date_min_max
   end

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

@@ -2,11 +2,17 @@ class Typero::HashType < Typero::Type
   error :en, :not_hash_type_error, 'value is not hash type'
 
   def set
-    error_for(:not_hash_type_error) unless value.is_a?(Hash)
+    if value.is_a?(String) && value[0,1] == '{'
+      @value = JSON.load(value)
+    end
+
+    @value ||= {}
+
+    error_for(:not_hash_type_error) unless @value.respond_to?(:keys) && @value.respond_to?(:values)
 
     if opts[:allow]
-      for key in value.keys
-        value.delete(key) unless opts[:allow].include?(key)
+      for key in @value.keys
+        @value.delete(key) unless opts[:allow].include?(key)
       end
     end
   end

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

@@ -0,0 +1,13 @@
+class Typero::LocaleType < Typero::Type
+  error :en, :locale_bad_format, 'Locale "%s" is in bad format (should be xx or xx-xx)'
+
+  def set
+    error_for(:locale_bad_format, value) unless value =~ /^[\w\-]{2,5}$/
+  end
+
+  def db_schema
+    [:string, { limit: 5 }]
+  end
+end
+
+

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

@@ -2,14 +2,16 @@ class Typero::ModelType < Typero::Type
   def set
     value(&:to_h)
 
-    errors = []
+    errors = {}
 
-    schema = Typero.schema(opts[:model])
-    schema.validate(value) do |field, error|
-      errors.push '%s (%s)' % [error, field]
+    schema = opts[:model].is_a?(Typero::Schema) ? opts[:model] : Typero.schema(opts[:model])
+
+    # by default models in schems are strict true (remove undefined keys)
+    schema.validate value, strict: true do |field, error|
+      errors[field] = error
     end
 
-    raise TypeError.new errors.join(', ') if errors.first
+    raise TypeError.new errors.to_json if errors.keys.first
   end
 
   def db_schema

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

@@ -0,0 +1,5 @@
+require_relative 'datetime_type'
+
+class Typero::TimeType < Typero::DatetimeType
+end
+

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

@@ -0,0 +1,15 @@
+class Typero::TimezoneType < Typero::Type
+  error :en, :invalid_time_zone, 'Invalid time zone'
+
+  def set
+    TZInfo::Timezone.get(value)
+  rescue TZInfo::InvalidTimezoneIdentifier
+    error_for :invalid_time_zone
+  end
+
+  def db_schema
+    [:string, { length: 50 }]
+  end
+
+end
+

data/lib/typero/typero.rb

@@ -35,29 +35,40 @@ module Typero
     end
   end
 
-  # load type schema
-  def schema name=nil, &block
-    # :user -> 'User'
-    name = name.to_s.classify if name
+  # load or set type schema
+  # Typero.schema(:blog) { ... }
+  # Typero.schema(:blog, type: :model) { ... }
+  # Typero.schema(:blog)
+  # Typero.schema(type: :model)
+  def schema name=nil, opts=nil, &block
+    klass = name.to_s.classify if name && !name.is_a?(Hash)
 
     if block_given?
       Typero::Schema.new(&block).tap do |schema|
-        Typero::Schema::SCHEMAS[name] = schema if name
-      end
-    else
-      raise ArgumentErorr.new('Schema name not given') unless name
+        if klass
+          Typero::Schema::SCHEMAS[klass] = schema
 
-      schema   = Typero::Schema::SCHEMAS[name]
-      schema ||= class_finder name, :schema
-      schema || raise('Typero schema "%s" not defined' % name)
-    end
-  end
-
-  def export model, opts={}, &block
-    if block_given?
-      Exporter::EXPORTERS[model.to_s.classify] = block
+          if opts && opts[:type]
+            Typero::Schema::TYPES[opts[:type]] ||= []
+            Typero::Schema::TYPES[opts[:type]].push klass unless Typero::Schema::TYPES[opts[:type]].include?(klass)
+          end
+        end
+      end
     else
-      Exporter.new(model, opts).render
+      # Schema not given, get schema
+      if name.is_a?(Hash)
+        # Typero.schema type: :model
+        if type = name[:type]
+          Typero::Schema::TYPES[type]
+        end
+      elsif klass
+        # Typero.schema :user
+        schema   = Typero::Schema::SCHEMAS[klass]
+        schema ||= class_finder klass, :schema
+        schema || nil
+      else
+        raise ArgumentError, 'Schema type not defined.'
+      end
     end
   end
 
@@ -78,13 +89,10 @@ module Typero
     for el in args
       for separator in ['_','/']
         klass = [name, el].join(separator).classify
-
-        begin
-          return klass.constantize
-        rescue NameError => e
-          nil
-        end
+        return klass.constantize if const_defined? klass
       end
     end
+
+    nil
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.3
 platform: ruby
 authors:
 - Dino Reic
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-02 00:00:00.000000000 Z
+date: 2021-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
@@ -34,7 +34,6 @@ files:
 - "./.version"
 - "./lib/adapters/sequel.rb"
 - "./lib/typero.rb"
-- "./lib/typero/exporter.rb"
 - "./lib/typero/params.rb"
 - "./lib/typero/schema.rb"
 - "./lib/typero/type/type.rb"
@@ -48,18 +47,21 @@ files:
 - "./lib/typero/type/types/image_type.rb"
 - "./lib/typero/type/types/integer_type.rb"
 - "./lib/typero/type/types/label_type.rb"
+- "./lib/typero/type/types/locale_type.rb"
 - "./lib/typero/type/types/model_type.rb"
 - "./lib/typero/type/types/oib_type.rb"
 - "./lib/typero/type/types/point_type.rb"
 - "./lib/typero/type/types/string_type.rb"
 - "./lib/typero/type/types/text_type.rb"
+- "./lib/typero/type/types/time_type.rb"
+- "./lib/typero/type/types/timezone_type.rb"
 - "./lib/typero/type/types/url_type.rb"
 - "./lib/typero/typero.rb"
 homepage: https://github.com/dux/typero
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -75,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Ruby type system
 test_files: []

data/lib/typero/exporter.rb

@@ -1,93 +0,0 @@
-module Typero
-  class Exporter
-    EXPORTERS ||= {}
-
-    attr_accessor :response
-
-    def initialize model, opts={}
-      opts = { user: opts } unless opts.is_a?(Hash)
-
-      opts[:exporter]      ||= model.class
-      opts[:depth]         ||= 1
-      opts[:current_depth] ||= 0
-
-      exporter = opts.delete(:exporter).to_s.classify
-
-      @model    = model
-      @opts     = opts
-      @block    = EXPORTERS[exporter] || raise('Exporter "%s" (:%s) not found' % [block, block.underscore])
-      @response = {}
-    end
-
-    def render
-      instance_exec &@block
-      @response
-    end
-
-    private
-
-    def export object, opts={}
-      if object.is_a?(Symbol)
-        return property object, export(model.send(object))
-      end
-
-      return if @opts[:current_depth] >= @opts[:depth]
-
-      @opts[:current_depth] += 1
-      out = self.class.new(object, @opts.merge(opts)).render
-      @opts[:current_depth] -= 1
-      out
-    end
-
-    def property name, data=:_undefined
-      if block_given?
-        data = yield if data == :_undefined
-        @response[name] = data
-      else
-        data = data == :_undefined ? model.send(name) : data
-
-        if data.respond_to?(:export_json)
-          data = data.export_json
-        elsif data.respond_to?(:to_h)
-          data = data.to_h
-        end
-
-        @response[name] = data
-      end
-    end
-    alias :prop :property
-
-    def hproperty name
-      @response[name] = model[name]
-    end
-    alias :hprop :hproperty
-
-    def namespace name, &block
-
-    end
-
-    def meta &block
-      namespace :meta, &block
-    end
-
-    def model
-      @model
-    end
-
-    # get current user from globals if globals defined
-    def user
-      if @opts[:user]
-        @opts[:user]
-      elsif defined?(User) && User.respond_to?(:current)
-        User.current
-      elsif defined?(Current) && Current.respond_to?(:user)
-        Current.user
-      elsif current_user = Thread.current[:current_user]
-        current_user
-      else
-        nil
-      end
-    end
-  end
-end
-