typero 0.9.6 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54d18d3e66cf73fd0d6f6c42f319cb744fb3cc3f5e11e5e4a24b961c36792a34
-  data.tar.gz: 65f87c041f1a498c82d707d897d93eab7294a0d373a4d9aca5ec9aefe5da27b7
+  metadata.gz: 988ca72b1b08538ccf6bf49e2fcd449a97b4b403bc8306e6d9c1242df6ae0a54
+  data.tar.gz: dd90e591bc0b9790e60656e8f6a342b033ab2adca4d80b80a6a1e702878f895e
 SHA512:
-  metadata.gz: 1a63e1a470f0e21162f3c11e40fe4977b4432bb30d3f154330840f344b1dc91c49dc453213139b8e5299f4afe587ae3bf6427fa0aabedd0cc0910188e6463ca5
-  data.tar.gz: 0dd2e24597fa25a0543b851fa3218fc69e129fa671c3ed52edf6110994876c14e3ceb88002ebfec130782722b51dee184cf30dbb0012384da9eba7654d8db24c
+  metadata.gz: 8940ebb5034757bb9c4a285b0e6e74bc65131ab5bdebdd9154b0643843836c5cab7c2a98b988361181bea0cf38d461f40662bf9dda926d074bf7b5756f1d6312
+  data.tar.gz: e77d16947abb2762bc33ed5c5ba855da56924f2187bb8d31c067d614561cd3f44a07730f8fb858882baa0876ef55da9529a495695454a58bf5c2fe205b81e1f7

data/.version

@@ -1 +1 @@
-0.9.6
+0.10.0

data/lib/adapters/sequel.rb

@@ -2,8 +2,16 @@
 
 module Sequel::Plugins::Typero
   module ClassMethods
-    def typero
-      Typero.schema self
+    def schema name = nil, &block
+      name ||= self
+      name = name.to_s.underscore.singularize
+      value = Typero.schema name, type: :model, &block
+
+      if ENV['DB_MIGRATE'] == 'true' && defined?(AutoMigrate)
+        AutoMigrate.apply_schema self
+      end
+
+      value
     end
   end
 
@@ -12,31 +20,32 @@ module Sequel::Plugins::Typero
     def validate
       super
 
-      schema = Typero.schema(self.class) || return
-
-      schema.validate(self) do |name, err|
-        errors.add(name, err) unless (errors.on(name) || []).include?(err)
-      end
+      # Typero schema check
+      if schema = Typero.schema?(self.class)
+        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
-      schema.rules.each do |field, rule|
-        # check uniqe fields
-        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 = 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)
+        # this are rules unique to database, so we check them here
+        schema.rules.each do |field, rule|
+          # check uniqe fields
+          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 #{respond_to?(:ref) ? :ref : :id}::text<>?" % [field], value, id.to_s).first
+              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
-        end
 
-        # check protected fields
-        if prot = rule.dig(:meta, :protected) && self[:id]
-          if column_changed?(field)
-            error = prot.class == TrueClass ? "value once defined can't be overwritten." : prot
-            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          # check protected fields
+          if (prot = rule.dig(:meta, :protected)) && self[:id]
+            if column_changed?(field)
+              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
       end

data/lib/typero/{params.rb → define.rb}

@@ -1,14 +1,17 @@
-# Base class for schema validation.
-# Accepts set of params and returns hash of porsed rules
+# Base class for schema definition DSL.
+# Accepts a block of field declarations and returns hash of parsed rules.
+
+require 'set'
+require 'json'
 
 module Typero
-  class Params
+  class Define
     attr_reader :db_rules
 
-    def initialize &block
+    def initialize rules = nil, &block
       @db_rules = []
-      @rules    = {}
-      instance_exec &block
+      @rules    = rules || {}
+      instance_exec &block if block
     end
 
     def rules
@@ -21,6 +24,52 @@ module Typero
     def set field, *args, &block
       raise "Field name not given (Typero)" unless field
 
+      opts  = parse_args args
+      field = field.to_s
+
+      # bang suffix defines block type for all fields in the block
+      if field.include?('!')
+        return define_block_type(field, &block)
+      end
+
+      # question mark suffix makes field optional
+      field = parse_field_name field, opts
+
+      resolve_type opts
+
+      # inline block defines a nested model schema
+      if block_given?
+        opts[:type]  = :model
+        opts[:model] = Typero.schema &block
+      end
+
+      opts[:type] = opts[:type].to_s.downcase.to_sym
+      opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
+
+      validate_opts opts
+
+      field = field.to_sym
+      db(:add_index, field) if opts.delete(:index)
+
+      @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
+
+    # if method undefined, call set method
+    # age Integer -> set :age, type: :integer
+    def method_missing field, *args, &block
+      set field, *args, &block
+    end
+
+    # --- argument parsing ---
+
+    def parse_args args
       if args.first.is_a?(Hash)
         opts = args.first || {}
       else
@@ -29,22 +78,10 @@ module Typero
       end
 
       opts[:type] = :string if opts[:type].nil?
+      opts
+    end
 
-      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
+    def parse_field_name field, opts
       if field.include?('?')
         field = field.sub('?', '')
         opts[:required] = false
@@ -53,78 +90,66 @@ module Typero
       opts[:required] = opts.delete(:req) unless opts[:req].nil?
       opts[:required] = true if opts[:required].nil?
 
-      # array that allows duplicates
+      field
+    end
+
+    # --- type resolution ---
+
+    def define_block_type field, &block
+      raise ArgumentError, 'If you use ! you have to provide a block' unless block
+
+      field = field.sub('!', '')
+      @block_type = field.to_sym
+      instance_exec &block
+      @block_type = nil
+    end
+
+    def resolve_type opts
+      # bare Array or Set class -> array of strings
+      if opts[:type] == Array || opts[:type] == Set
+        opts[:type]  = :string
+        opts[:array] = true
+      end
+
+      # Array[:type] -> typed array
       if opts[:type].is_a?(Array)
         opts[:type]  = opts[:type].first
         opts[:array] = true
       end
 
-      # no duplicates array
+      # Set[:type] -> typed array (no duplicates)
       if opts[:type].is_a?(Set)
         opts[:type]  = opts[:type].to_a.first
         opts[:array] = true
       end
 
+      # block type override (integer! do ... end)
       opts[:type] = @block_type if @block_type
 
-      # Boolean
+      # boolean variants
       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[:required] = false
         opts[:default]  = false if opts[:default].nil?
         opts[:type]     = :boolean
       end
 
-      # model / schema
-      if opts[:type].class.ancestors.include?(Typero::Schema)
+      # model / schema reference
+      if opts[:type].is_a?(Typero::Schema)
         opts[:model] = opts.delete(:type)
       end
       opts[:model] = opts.delete(:schema) if opts[:schema]
       opts[:type]  = :model if opts[:model]
+    end
 
-      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
+    def validate_opts opts
+      type = Typero::Type.load opts[:type]
       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)
-
-      # 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.unshift(:db_rule!)
-    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

@@ -1,38 +1,18 @@
-# Typero.schema :user, type: :model do
-
-# Typero.schema :some_name, type: :model, db: DB_LOG do
-#   set :name, String, req: true
-#   set :email, :email, req: true
-#   set :emails, [:email], min: 2
-# end
-#
-# rules = Typero.schema :some_name
-#
-# or
-#
-# rules = Typero.schema do
-#   string :name, req: true    # generic email string
-#   email :email, req: true    # string of type email
-#   emails [:skills], min: 2   # list of emails in filed named "emails"
-# end
-#
-# errors = rules.validate (@object || @hash)
-# rules.valid? (@object)
-# rules.validate(@object) {|errors| ... }
-
 module Typero
   class Schema
     SCHEMA_STORE ||= {}
 
-    attr_reader :klass
-    attr_reader :schema
-    attr_reader :opts
+    attr_reader :klass, :opts
+
+    # accepts dsl block to define schema
+    # or define: keyword for internal use (only/except)
+    def initialize name, opts = nil, define: nil, &block
+      @opts = opts || {}
 
-    # accepts dsl block to
-    def initialize name, opts = nil, &block
-      if block
-        @opts   = opts || {}
-        @schema = Params.new &block
+      if define
+        @schema = define
+      elsif block
+        @schema = Define.new &block
 
         if name
           @klass = name
@@ -43,78 +23,48 @@ module Typero
       end
     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
+    # returns new schema with only specified keys
+    def only *keys
+      keys = keys.map(&:to_sym)
+      filtered = rules.select { |k, _| keys.include?(k) }
+      self.class.new(nil, define: Define.new(filtered))
+    end
 
-        if opts[:array]
-          unless value.respond_to?(:each)
-            opts[:delimiter] ||= /\s*[,\n]\s*/
-            value = value.to_s.split(opts[:delimiter])
-          end
+    # returns new schema without specified keys
+    def except *keys
+      keys = keys.map(&:to_sym)
+      filtered = rules.reject { |k, _| keys.include?(k) }
+      self.class.new(nil, define: Define.new(filtered))
+    end
 
-          value = value
-            .flatten
-            .map { |el| el.to_s == '' ? nil : check_filed_value(field, el, opts) }
-            .compact
+    # validates any instance object with hash variable interface
+    # it also coerces values
+    def validate object, options = nil
+      @object = object
+      @errors = {}
+      options ||= {}
 
-          value = Set.new(value).to_a unless opts[:duplicates]
+      strip_undefined_keys! if options[:strict] && object.is_a?(Hash)
 
-          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]
+      @schema.rules.each do |field, raw_opts|
+        field = field.to_sym
+        opts = resolve_opts(raw_opts)
 
-          add_required_error field, value.first, opts
-        else
-          value = nil if value.to_s == ''
+        apply_default field, opts
+        value = read_value field
 
-          # if value is not list of allowed values, raise error
-          allowed = opts[:allow] || opts[:allowed] || opts[:values]
-          if value && allowed && !allowed.map(&:to_s).include?(value.to_s)
-            add_error field, 'Value "%s" is not allowed' % value, opts
+        value =
+          if opts[:array]
+            validate_array field, value, opts
+          else
+            validate_scalar field, 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
+        @object[field] = blank?(value) ? nil : value
       end
 
-      if @errors.keys.length > 0 && block_given?
+      if @errors.any? && block_given?
         @errors.each { |k, v| yield(k, v) }
       end
 
@@ -122,29 +72,24 @@ module Typero
     end
 
     def valid? object
-      errors = validate object
-      errors.keys.length == 0
+      validate(object).empty?
+    end
+
+    # returns raw db rules like [:timestamps] or [:add_index, :code]
+    def db_rules
+      @schema.db_rules
     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 << [field, type, opts]
+      @schema.rules.map do |field, opts|
+        type, db_opts = Typero::Type.load(opts[:type]).new(nil, opts).db_field
+        db_opts[:array] = true if opts[:array]
+        [field, type, db_opts]
       end
-
-      out += @schema.db_rules
-
-      out
     end
 
-    # iterate trough all the ruels via block interface
+    # iterate through all the rules via block interface
     # schema.rules do |field, opts|
     # schema.rules(:url) do |field, opts|
     def rules filter = nil, &block
@@ -159,7 +104,92 @@ module Typero
 
     private
 
-    # adds error to array or prefixes with field name
+    # remove keys not defined in schema
+    def strip_undefined_keys!
+      defined_keys = @schema.rules.keys.map(&:to_s)
+      @object.delete_if { |k, _| !defined_keys.include?(k.to_s) }
+    end
+
+    # dup opts so Proc resolution does not mutate stored schema
+    def resolve_opts raw_opts
+      opts = raw_opts.dup
+      opts.each do |k, v|
+        opts[k] = @object.instance_exec(&v) if v.is_a?(Proc)
+      end
+      opts
+    end
+
+    def apply_default field, opts
+      if !opts[:default].nil? && @object[field].to_s.blank?
+        @object[field] = opts[:default]
+      end
+    end
+
+    # read value from object, normalizing string keys to symbols for Hash
+    def read_value field
+      if @object.respond_to?(:key?)
+        if @object.key?(field)
+          @object[field]
+        elsif @object.key?(field.to_s)
+          @object[field] = @object.delete(field.to_s)
+        end
+      else
+        @object[field]
+      end
+    end
+
+    def validate_array field, value, opts
+      unless value.respond_to?(:each)
+        delimiter = opts[:delimiter] || /\s*[,\n]\s*/
+        value = value.to_s.split(delimiter)
+      end
+
+      value = value
+        .flatten
+        .map { |el| el.to_s == '' ? nil : coerce_value(field, el, opts) }
+        .compact
+
+      value = Set.new(value).to_a unless opts[:duplicates]
+
+      max_count = opts[:max_count] || 100
+      add_error(field, 'Max number of array elements is %d, you have %d' % [max_count, value.length], opts) if value.length > max_count
+      add_error(field, 'Min number of array elements is %d, you have %d' % [opts[:min_count], value.length], opts) if opts[:min_count] && value.length < opts[:min_count]
+
+      add_required_error field, value.first, opts
+      value
+    end
+
+    def validate_scalar field, value, opts
+      value = nil if value.to_s == ''
+
+      allowed = opts[:allow] || opts[:allowed] || opts[:values]
+      if value && allowed && !allowed.map(&:to_s).include?(value.to_s)
+        add_error field, 'Value "%s" is not allowed' % value, opts
+      end
+
+      value = coerce_value field, value, opts
+      add_required_error field, value, opts
+      value
+    end
+
+    # coerce a single value through its type class
+    def coerce_value field, value, opts
+      klass = Typero::Type.load(opts[:type])
+      check = klass.new value, opts
+      check.get
+    rescue TypeError => e
+      if e.message[0] == '{'
+        JSON.parse(e.message).each do |key, msg|
+          add_error [field, key].join('.'), msg, opts
+        end
+      else
+        add_error field, e.message, opts
+      end
+    rescue JSON::ParserError
+      add_error field, e.message, opts
+    end
+
+    # adds error to hash, prefixing with field name if message starts lowercase
     def add_error field, msg, opts
       if @errors[field]
         @errors[field] += ", %s" % msg
@@ -173,28 +203,14 @@ module Typero
       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
+    def blank? value
+      value.to_s.sub(/\s+/, '') == ''
     end
   end
 end

data/lib/typero/type/geo_extract.rb

@@ -0,0 +1,75 @@
+# Shared coordinate extraction from map URLs and plain lat,lon strings.
+# Returns [lat, lon] as strings, or nil if no match.
+
+module Typero
+  module GeoExtract
+    # extract lat, lon from various map URLs or plain "lat,lon" string
+    def extract_coords data
+      data = data.to_s.strip
+
+      coords = extract_from_url(data) || extract_from_string(data)
+      return nil unless coords
+
+      coords.map { |c| c.to_s.strip }
+    end
+
+    private
+
+    def extract_from_url data
+      return nil unless data.include?('://')
+
+      # Google Maps: /@45.815,15.982,... or ?q=45.815,15.982
+      if data.include?('/@')
+        parts = data.split('/@', 2).last.split(',')
+        return [parts[0], parts[1]] if parts.length >= 2
+      end
+
+      if data =~ /google.*[?&]q=([-\d.]+),([-\d.]+)/
+        return [$1, $2]
+      end
+
+      # OpenStreetMap: /#map=15/45.815/15.982
+      if data =~ /openstreetmap.*#map=\d+\/([-\d.]+)\/([-\d.]+)/
+        return [$1, $2]
+      end
+
+      # OpenStreetMap: ?mlat=45.815&mlon=15.982
+      if data =~ /openstreetmap.*[?&]mlat=([-\d.]+).*[?&]mlon=([-\d.]+)/
+        return [$1, $2]
+      end
+
+      # Apple Maps: ?ll=45.815,15.982
+      if data =~ /maps\.apple\.com.*[?&]ll=([-\d.]+),([-\d.]+)/
+        return [$1, $2]
+      end
+
+      # Waze: ?ll=45.815,15.982
+      if data =~ /waze\.com.*[?&]ll=([-\d.]+),([-\d.]+)/
+        return [$1, $2]
+      end
+
+      # Bing Maps: ?cp=45.815~15.982
+      if data =~ /bing\.com.*[?&]cp=([-\d.]+)~([-\d.]+)/
+        return [$1, $2]
+      end
+
+      # Bing Maps: /point.45.815_15.982
+      if data =~ /bing\.com.*point\.([-\d.]+)_([-\d.]+)/
+        return [$1, $2]
+      end
+
+      nil
+    end
+
+    def extract_from_string data
+      return nil if data.include?('://') || data.include?('POINT')
+
+      if data.include?(',')
+        parts = data.split(/\s*,\s*/)
+        return [parts[0], parts[1]] if parts.length >= 2
+      end
+
+      nil
+    end
+  end
+end

data/lib/typero/type/type.rb

@@ -5,12 +5,12 @@ module Typero
     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_length_error: 'min length is %s, you have %s',
+        max_length_error: 'max length 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',
-        not_in_range: 'Value in not in allowed range (%s)'
+        not_in_range: 'Value is not in allowed range (%s)'
       }
     }
 
@@ -23,6 +23,8 @@ module Typero
       :default,
       :description,
       :delimiter,
+      :duplicates,
+      :index,
       :max_count,
       :meta,
       :min_count,
@@ -80,7 +82,7 @@ module Typero
     ###
 
     def initialize value, opts={}, &block
-      value = value.strip.rstrip if value.is_a?(String)
+      value = value.strip if value.is_a?(String)
 
       opts.keys.each {|key| self.class.allowed_opt?(key) }
 
@@ -101,7 +103,7 @@ module Typero
       if value.nil?
         opts[:default].nil? ? default : opts[:default]
       else
-        set
+        coerce
 
         if opts[:values] && !opts[:values].map(&:to_s).include?(@value.to_s)
           error_for(:not_in_range, opts[:values].join(', '))

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

@@ -1,7 +1,7 @@
 class Typero::BooleanType < Typero::Type
   error :en, :unsupported_boolean, 'Unsupported boolean param value: %s'
 
-  def set
+  def coerce
     value do |_|
       bool = _.to_s
 

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

@@ -6,8 +6,11 @@ require_relative './float_type'
 
 class Typero::CurrencyType < Typero::FloatType
 
-  def set
+  def coerce
     value { |data| data.to_f.round(2) }
+
+    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_schema

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

@@ -2,12 +2,17 @@ class Typero::DateType < Typero::Type
   opts :min, 'Smallest date-time allowed'
   opts :max, 'Maximal date-time allowed'
 
+  error :en, :invalid_date, 'is not a valid date'
   error :en, :min_date, 'Minimal allowed date is %s'
   error :en, :max_date, 'Maximal allowed date is %s'
 
-  def set
+  def coerce
     unless [Date].include?(value.class)
-      value { |data| DateTime.parse(data) }
+      begin
+        value { |data| DateTime.parse(data.to_s) }
+      rescue Date::Error, ArgumentError
+        error_for(:invalid_date)
+      end
     end
 
     value { |data| DateTime.new(data.year, data.month, data.day) }
@@ -24,12 +29,12 @@ class Typero::DateType < Typero::Type
   def check_date_min_max
     if min = opts[:min]
       min = DateTime.parse(min)
-      error_for(:min_date, min) % min if min > value
+      error_for(:min_date, min) if min > value
     end
 
     if max = opts[:max]
       max = DateTime.parse(max)
-      error_for(:max_date, max) % max if value > max
+      error_for(:max_date, max) if value > max
     end
 
     value

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

@@ -4,16 +4,22 @@ class Typero::DatetimeType < Typero::DateType
   opts :min, 'Smallest date allowed'
   opts :max, 'Maximal date allowed'
 
-  def set
+  error :en, :invalid_datetime, 'is not a valid datetime'
+
+  def coerce
     unless [Time, DateTime].include?(value.class)
-      value { |data| DateTime.parse(data) }
+      begin
+        value { |data| DateTime.parse(data.to_s) }
+      rescue Date::Error, ArgumentError
+        error_for(:invalid_datetime)
+      end
     end
 
     check_date_min_max
   end
 
   def db_schema
-    [:datetime]
+    [:timestamp]
   end
 end
 

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

@@ -2,7 +2,7 @@ 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
+  def coerce
     value do |email|
       email.downcase.gsub(/\s+/,'+')
     end

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

@@ -1,24 +1,20 @@
 class Typero::FloatType < Typero::Type
   opts :min, 'Minimum value'
-  opts :max, 'Maximun value'
+  opts :max, 'Maximum value'
   opts :round, 'Round to (decimal spaces)'
 
-  def set
-    @value =
+  def coerce
     if opts[:round]
-      value.to_f.round(opts[:round])
+      value { |data| data.to_f.round(opts[:round]) }
     else
-      value.to_f
+      value { |data| data.to_f }
     end
 
-    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]
+    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_schema
-    opts = {}
-    opts[:null] = false if opts[:required]
-    [:float, opts]
+    [:float, {}]
   end
 end
-

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

@@ -1,13 +1,13 @@
 class Typero::HashType < Typero::Type
   error :en, :not_hash_type_error, 'value is not hash type'
 
-  def set
+  def coerce
     if value.is_a?(String) && value[0,1] == '{'
-      @value = JSON.load(value)
+      @value = JSON.parse(value)
     end
 
     @value ||= {}
-    @value.delete_if {|_, v| v.empty? }
+    @value.delete_if {|_, v| v.respond_to?(:empty?) && v.empty? }
 
     error_for(:not_hash_type_error) unless @value.respond_to?(:keys) && @value.respond_to?(:values)
 

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

@@ -6,11 +6,13 @@ class Typero::ImageType < Typero::Type
 
   opts :strict, 'Force image to have known extension (%s)' % FORMATS.join(', ')
 
-  def set
+  def coerce
     error_for(:image_not_starting_error) unless value =~ /^https?:\/\/./
 
     if opts[:strict]
-      ext = value.split('.').last.downcase
+      # strip query string and fragment before checking extension
+      path = value.split('?').first.split('#').first
+      ext = path.split('.').last.downcase
       error_for(:image_not_image_format) unless FORMATS.include?(ext)
     end
   end

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

@@ -1,8 +1,8 @@
 class Typero::IntegerType < Typero::Type
   opts :min, 'Minimum value'
-  opts :max, 'Maximun value'
+  opts :max, 'Maximum value'
 
-  def set
+  def coerce
     value(&:to_i)
 
     error_for(:min_value_error, opts[:min], value) if opts[:min] && value < opts[:min]

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

@@ -1,5 +1,5 @@
 class Typero::LabelType < Typero::Type
-  def set
+  def coerce
     value do |data|
       data
         .to_s

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

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

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

@@ -1,5 +1,5 @@
 class Typero::ModelType < Typero::Type
-  def set
+  def coerce
     value(&:to_h)
 
     errors = {}
@@ -10,7 +10,7 @@ class Typero::ModelType < Typero::Type
       errors[field] = error
     end
 
-    @value.delete_if {|_, v| v.empty? }
+    @value.delete_if {|_, v| v.respond_to?(:empty?) && v.empty? }
 
     raise TypeError.new errors.to_json if errors.keys.first
   end

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

@@ -1,9 +1,9 @@
 class Typero::OibType < Typero::Type
   error :en, :not_an_oib_error, 'not in an OIB format'
 
-  def set
+  def coerce
     value do |data|
-      check?(data) ? data.to_i : error_for(:not_an_oib_error)
+      check?(data) ? data.to_s : error_for(:not_an_oib_error)
     end
   end
 
@@ -22,7 +22,7 @@ class Typero::OibType < Typero::Type
     return false unless oib.match(/^[0-9]{11}$/)
 
     control_sum = (0..9).inject(10) do |middle, position|
-      middle += oib.at(position).to_i
+      middle += oib[position].to_i
       middle %= 10
       middle = 10 if middle == 0
       middle *= 2
@@ -32,7 +32,7 @@ class Typero::OibType < Typero::Type
     control_sum = 11 - control_sum
     control_sum = 0 if control_sum == 10
 
-    return control_sum == oib.at(10).to_i
+    return control_sum == oib[10].to_i
   end
 
 end

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

@@ -0,0 +1,15 @@
+class Typero::PhoneType < Typero::Type
+  error :en, :invalid_phone, 'is not a valid phone number'
+
+  def coerce
+    value do |data|
+      data.to_s.gsub(/[\(\)\-]/, ' ').gsub(/\s+/, ' ').strip
+    end
+
+    error_for(:invalid_phone) unless value =~ /^[\d\s\+]+$/ && value.scan(/\d/).length >= 5
+  end
+
+  def db_schema
+    [:string, { limit: 50 }]
+  end
+end

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

@@ -2,20 +2,17 @@
 # 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.include?('/@')
-      # extract value from google maps link
-      point = value.split('/@', 2).last.split(',')
-      value { [point[0], point[1]].join(',') }
-    end
+  include Typero::GeoExtract
 
-    if !value.include?('POINT') && value.include?(',')
-      point = value.sub(/\s*,\s*/, ' ')
-      value { 'SRID=4326;POINT(%s)' % point }
-    end
+  def coerce
+    if value.is_a?(String) && !value.include?('POINT')
+      coords = extract_coords(value)
 
-    if value && value.include?(',') && !value =~ /^SRID=4326;POINT\(/
-      error_for(:unallowed_characters_error)
+      if coords
+        value { 'SRID=4326;POINT(%s %s)' % [coords[0], coords[1]] }
+      else
+        error_for(:unallowed_characters_error)
+      end
     end
   end
 
@@ -23,4 +20,3 @@ class Typero::PointType < Typero::Type
     [:geography, {}]
   end
 end
-

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

@@ -1,15 +1,15 @@
-# Same as point, but we keep data as a float in Array
+# Same as point, but we keep data as a float array [lat, lon]
 
 class Typero::SimplePointType < Typero::Type
-  def set
-    if value.include?('/@')
-      # extract value from google maps link
-      point = value.split('/@', 2).last.split(',')[0,2]
-      value { point }
-    end
+  include Typero::GeoExtract
+
+  def coerce
+    coords = extract_coords(value)
 
-    if !value.include?('POINT') && value.include?(',')
-      value { value.split(/\s*,\s*/)[0,2] }
+    if coords
+      value { coords }
+    else
+      error_for(:unallowed_characters_error)
     end
   end
 
@@ -17,4 +17,3 @@ class Typero::SimplePointType < Typero::Type
     [:float, { array: true }]
   end
 end
-

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

@@ -0,0 +1,25 @@
+class Typero::SlugType < Typero::Type
+  opts :max, 'Maximum slug length'
+
+  error :en, :invalid_slug, 'contains invalid characters'
+
+  def coerce
+    max = opts[:max] || 255
+
+    value do |data|
+      data
+        .to_s
+        .downcase
+        .gsub(/[^\w\-]/, '-')
+        .gsub(/\-+/, '-')
+        .sub(/^\-/, '')
+        .sub(/\-$/, '')[0, max]
+    end
+
+    error_for(:invalid_slug) unless value =~ /^[\w][\w\-]*[\w]$|^[\w]$/
+  end
+
+  def db_schema
+    [:string, { limit: opts[:max] || 255 }]
+  end
+end

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

@@ -1,9 +1,9 @@
 class Typero::StringType < Typero::Type
-  opts :min, 'Minimun string length'
-  opts :max, 'Maximun string length'
+  opts :min, 'Minimum string length'
+  opts :max, 'Maximum string length'
   opts :downcase, 'is the string in downcase?'
 
-  def set
+  def coerce
     value(&:to_s)
     value(&:downcase) if opts[:downcase]
 

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

@@ -1,8 +1,16 @@
 require_relative 'string_type'
 
 class Typero::TextType < Typero::StringType
-  opts :min, 'Minimun string length'
-  opts :max, 'Maximun string length'
+  opts :min, 'Minimum string length'
+  opts :max, 'Maximum string length'
+
+  def coerce
+    value(&:to_s)
+    value(&:downcase) if opts[:downcase]
+
+    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_schema
     [:text, {}]

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

@@ -1,7 +1,7 @@
 class Typero::TimezoneType < Typero::Type
   error :en, :invalid_time_zone, 'Invalid time zone'
 
-  def set
+  def coerce
     TZInfo::Timezone.get(value)
   rescue TZInfo::InvalidTimezoneIdentifier
     error_for :invalid_time_zone

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

@@ -1,9 +1,8 @@
 class Typero::UrlType < Typero::Type
   error :en, :url_not_starting_error, 'URL is not starting with http or https'
 
-  def set
-    parts = value.split('://')
-    error_for(:url_not_starting_error) unless parts[1]
+  def coerce
+    error_for(:url_not_starting_error) unless value =~ /^https?:\/\//
   end
 
   def db_schema

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

@@ -0,0 +1,13 @@
+class Typero::UuidType < Typero::Type
+  error :en, :invalid_uuid, 'is not a valid UUID'
+
+  def coerce
+    value { |data| data.to_s.strip.downcase }
+
+    error_for(:invalid_uuid) unless value =~ /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+  end
+
+  def db_schema
+    [:string, { limit: 36 }]
+  end
+end

data/lib/typero/typero.rb

@@ -1,3 +1,5 @@
+# module quick access to other types
+
 module Typero
   extend self
 
@@ -50,7 +52,7 @@ module Typero
         #   Typero.schema type: :model
         out = []
 
-        for schema in Schema::SCHEMA_STORE.values
+        Schema::SCHEMA_STORE.values.each do |schema|
           if schema.opts[name.keys.first] == name.values.first
             out.push schema.klass
           end
@@ -64,6 +66,17 @@ module Typero
     end
   end
 
+  # same as schema but returns nil if not found
+  def schema? name
+    klass = name.to_s.classify if name
+    Typero::Schema::SCHEMA_STORE[klass] if klass
+  end
+
+  # get array of database fields, ruby Sequel compatibile
+  def db_schema name
+    Typero.schema(name).db_schema
+  end
+
   def defined? name
     Typero::Type.load name
     true

data/lib/typero.rb

@@ -3,8 +3,9 @@
 # base libs
 require_relative 'typero/typero'
 require_relative 'typero/schema'
-require_relative 'typero/params'
+require_relative 'typero/define'
 require_relative 'typero/type/type'
+require_relative 'typero/type/geo_extract'
 
 # checker types
 Dir['%s/typero/type/types/*.rb' % __dir__].each do |file|

metadata

@@ -1,29 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.9.6
+  version: 0.10.0
 platform: ruby
 authors:
 - Dino Reic
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-20 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: fast_blank
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: Simple and fast ruby type system. Enforce types as Array, Email, Boolean
   for ruby class instances
 email: reic.dino@gmail.com
@@ -34,8 +19,9 @@ files:
 - "./.version"
 - "./lib/adapters/sequel.rb"
 - "./lib/typero.rb"
-- "./lib/typero/params.rb"
+- "./lib/typero/define.rb"
 - "./lib/typero/schema.rb"
+- "./lib/typero/type/geo_extract.rb"
 - "./lib/typero/type/type.rb"
 - "./lib/typero/type/types/boolean_type.rb"
 - "./lib/typero/type/types/currency_type.rb"
@@ -50,19 +36,21 @@ files:
 - "./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/phone_type.rb"
 - "./lib/typero/type/types/point_type.rb"
 - "./lib/typero/type/types/simple_point_type.rb"
+- "./lib/typero/type/types/slug_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/type/types/uuid_type.rb"
 - "./lib/typero/typero.rb"
 homepage: https://github.com/dux/typero
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -77,8 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 4.0.8
 specification_version: 4
 summary: Ruby type system
 test_files: []