typero 0.4.0 → 0.9.0

data/lib/typero/schema.rb

@@ -0,0 +1,132 @@
+module Typero
+  class Schema
+    SCHEMAS = {}
+
+    # 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]
+
+          add_required_error field, value.first, opts
+        else
+          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
+
+      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
+      add_error field, e.message, opts
+    end
+  end
+end

data/lib/typero/type/type.rb

@@ -0,0 +1,110 @@
+# Master class
+
+module 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',
+        not_in_range: 'Value in not in allowed range (%s)'
+      }
+    }
+
+    # default shared allowed opts keys
+    OPTS_KEYS = [:type, :required, :array, :max_count, :default, :name, :meta, :model]
+    OPTS      = {}
+
+    attr_reader :opts
+
+    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_KEYS.push key unless OPTS_KEYS.include?(key)
+
+        OPTS[self] ||= {}
+        OPTS[self][key] = desc
+      end
+    end
+
+    ###
+
+    def initialize value, opts={}, &block
+      value = value.sub(/^\s+/, '').sub(/\s+$/, '') if value.is_a?(String)
+
+      @value = value
+      @opts  = opts
+      @block = block
+    end
+
+    def value &block
+      if block_given?
+        @value = block.call @value
+      else
+        @value
+      end
+    end
+
+    def get
+      if value.nil?
+        opts[:default].nil? ? default : opts[:default]
+      else
+        set
+        error_for(:not_in_range, opts[:values].join(', ')) if opts[:values] && !opts[:values].include?(@value)
+        value
+      end
+    end
+
+    def default
+      nil
+    end
+
+    def db_field
+      out = db_schema
+      out[1] ||= {}
+      out[1][:default] ||= opts[:default] unless opts[:default].nil?
+      out[1][:null]      = false if !opts[:array] && opts[:required]
+      out
+    end
+
+    private
+
+    # get error from option or the default one
+    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/types/boolean_type.rb

@@ -0,0 +1,26 @@
+class Typero::BooleanType < Typero::Type
+  error :en, :unsupported_boolean, 'Unsupported boolean param value: %s'
+
+  def set
+    value do |_|
+      bool = _.to_s
+
+      if value == ''
+        false
+      elsif %w(true 1 on).include?(bool)
+        true
+      elsif %w(false 0 off).include?(bool)
+        false
+      else
+        error_for :unsupported_boolean, bool
+      end
+    end
+  end
+
+  def db_schema
+    [:boolean, {
+      default: opts[:default] || false
+    }]
+  end
+end
+

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

@@ -0,0 +1,21 @@
+# you should not use this filed for currency calculations
+# use integer and covert in code
+# Example: use cents and divide by 100 for $
+
+require_relative './float_type'
+
+class Typero::CurrencyType < Typero::FloatType
+
+  def set
+    value { |data| data.to_f.round(2) }
+  end
+
+  def db_schema
+    [:decimal, {
+      precision: 8,
+      scale:     2
+    }]
+  end
+
+end
+

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

@@ -0,0 +1,32 @@
+class Typero::DateType < Typero::Type
+  error :en, :min_date, 'Minimal allowed date is %s'
+  error :en, :max_date, 'Maximal allowed date is %s'
+
+  def set
+    value { |data| DateTime.parse(data) }
+    value { |data| DateTime.new(data.year, data.month, data.day) }
+
+    check_date_min_max
+  end
+
+  def db_schema
+    [:date, {}]
+  end
+
+  private
+
+  def check_date_min_max
+    if min = opts[:min]
+      min = DateTime.parse(min)
+      error_for(:min_date, min) % min if min > value
+    end
+
+    if max = opts[:max]
+      max = DateTime.parse(max)
+      error_for(:max_date, max) % max if value > max
+    end
+
+    value
+  end
+end
+

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

@@ -0,0 +1,14 @@
+require_relative 'date_type'
+
+class Typero::DatetimeType < Typero::DateType
+  def set
+    value { |data| DateTime.parse(data) }
+
+    check_date_min_max
+  end
+
+  def db_schema
+    [:datetime]
+  end
+end
+

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

@@ -0,0 +1,20 @@
+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 do |email|
+      email.downcase.gsub(/\s+/,'+')
+    end
+
+    error_for(:not_8_chars_error) unless value.to_s.length > 7
+    error_for(:missing_monkey_error) unless value.include?('@')
+  end
+
+  def db_schema
+    [:string, {
+      limit: @opts[:max] || 120
+    }]
+  end
+end
+

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

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

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

@@ -0,0 +1,25 @@
+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 opts[:allow]
+      for key in value.keys
+        value.delete(key) unless opts[:allow].include?(key)
+      end
+    end
+  end
+
+  def default
+    {}
+  end
+
+  def db_schema
+    [:jsonb, {
+      null: false,
+      default: '{}'
+    }]
+  end
+end
+

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

@@ -0,0 +1,22 @@
+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
+    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_schema
+    [:string]
+  end
+end
+

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

@@ -0,0 +1,16 @@
+class Typero::IntegerType < Typero::Type
+  opts :min, 'Minimum value'
+  opts :max, 'Maximun value'
+
+  def set
+    value(&:to_i)
+
+    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
+    [:integer, {}]
+  end
+end
+