typero 0.8.0 → 0.9.4

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,38 @@
+class Typero::DateType < Typero::Type
+  opts :min, 'Smallest date-time allowed'
+  opts :max, 'Maximal date-time allowed'
+
+  error :en, :min_date, 'Minimal allowed date is %s'
+  error :en, :max_date, 'Maximal allowed date is %s'
+
+  def set
+    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
+  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,19 @@
+require_relative 'date_type'
+
+class Typero::DatetimeType < Typero::DateType
+  opts :min, 'Smallest date allowed'
+  opts :max, 'Maximal date allowed'
+
+  def set
+    unless [Time, DateTime].include?(value.class)
+      value { |data| DateTime.parse(data) }
+    end
+
+    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,31 @@
+class Typero::HashType < Typero::Type
+  error :en, :not_hash_type_error, 'value is not hash type'
+
+  def set
+    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)
+      end
+    end
+  end
+
+  def default
+    {}
+  end
+
+  def db_schema
+    [:jsonb, {
+      null: false,
+      default: '{}'
+    }]
+  end
+end
+

data/lib/typero/type/types/{image.rb → image_type.rb}

@@ -7,22 +7,16 @@ class Typero::ImageType < Typero::Type
   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?:\/\/./
+    error_for(:image_not_starting_error) unless value =~ /^https?:\/\/./
 
     if opts[:strict]
-      ext = @value.split('.').last.downcase
+      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]
+  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
+

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

@@ -0,0 +1,20 @@
+class Typero::LabelType < Typero::Type
+  def set
+    value do |data|
+      data
+        .to_s
+        .gsub(/\s+/,'-')
+        .gsub(/[^\w\-]/,'')
+        .gsub(/\-+/, '-')[0,30]
+        .downcase
+    end
+
+    error_for(:unallowed_characters_error) unless value =~ /^[\w\-]+$/
+  end
+
+  def db_schema
+    [:string, {
+      limit: 30
+    }]
+  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

@@ -0,0 +1,23 @@
+class Typero::ModelType < Typero::Type
+  def set
+    value(&:to_h)
+
+    errors = {}
+
+    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.to_json if errors.keys.first
+  end
+
+  def db_schema
+    [:jsonb, {
+      null: false
+    }]
+  end
+end
+

data/lib/typero/type/types/{oib.rb → oib_type.rb}

@@ -2,18 +2,15 @@ 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)
+    value do |data|
+      check?(data) ? data.to_i : error_for(:not_an_oib_error)
+    end
   end
 
-  def db_field
-    opts = {}
-    opts[:null]  = false if @opts[:required]
-    opts[:limit] = 11
-    [:string, opts]
+  def db_schema
+    [:string, {
+      limit: 11
+    }]
   end
 
   private

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

@@ -0,0 +1,25 @@
+# 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.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
+
+    if value && value.include?(',') && !value =~ /^SRID=4326;POINT\(/
+      error_for(:unallowed_characters_error)
+    end
+  end
+
+  def db_schema
+    [:geography, {}]
+  end
+end
+

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

@@ -0,0 +1,23 @@
+class Typero::StringType < Typero::Type
+  opts :min, 'Minimun string length'
+  opts :max, 'Maximun string length'
+  opts :downcase, 'is the string in downcase?'
+
+  def set
+    value(&:to_s)
+    value(&:downcase) if opts[:downcase]
+
+    # this is database default for string type and it is good to define default unless defined
+    opts[:max] ||= 255
+
+    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
+    [:string, {
+      limit: @opts[:max] || 255
+    }]
+  end
+end
+

data/lib/typero/type/types/{text.rb → text_type.rb}

@@ -1,12 +1,10 @@
-require_relative 'string'
+require_relative 'string_type'
 
 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]
+  def db_schema
+    [:text, {}]
   end
 end

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/type/types/url_type.rb

@@ -0,0 +1,13 @@
+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]
+  end
+
+  def db_schema
+    [:string, {}]
+  end
+end
+

data/lib/typero/typero.rb

@@ -1,4 +1,4 @@
-# rules = Typero.new do
+# rules = Typero.schema do
 #   set :name, String, req: true
 #   set :email, :email, req: true
 #   set :skills, [:email], min: 2
@@ -6,7 +6,7 @@
 #
 # or
 #
-# rules = Typero.new do
+# rules = Typero.schema do
 #   string :name, req: true
 #   email :email, req: true
 #   email [:skills], min: 2
@@ -16,162 +16,93 @@
 # 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
-
-  ###
+module Typero
+  extend self
 
-  # 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?
+  VERSION = File.read File.expand_path "../../.version", File.dirname(__FILE__)
 
-      # get field value
-      value = @object[field]
+  # check and coerce value
+  # Typero.type(:label) -> Typero::LabelType
+  # Typero.type(:label, 'Foo bar') -> "foo-bar"
+  def type klass_name, value = :_undefined, opts = {}, &block
+    klass = Typero::Type.load(klass_name)
 
-      if opts[:array]
-        unless value.is_a?(Array)
-          opts[:delimiter] ||= /\s*,\s*/
-          value = value.to_s.split(opts[:delimiter])
+    if value == :_undefined
+      klass
+    else
+      begin
+        check = klass.new value, opts
+        check.get
+      rescue TypeError => error
+        if block
+          block.call error
+          false
+        else
+          raise error
         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
+  alias :set :type
+
+  # 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|
+        if klass
+          Typero::Schema::SCHEMAS[klass] = schema
+
+          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
-      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]
+      # 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
-
-      @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
+  def defined? name
+    Typero::Type.load name
+    true
+  rescue ArgumentError
+    false
   end
 
-  def check_filed_value field, value, opts
-    return unless value
+  private
 
-    klass = "Typero::%sType" % safe_type(opts[:type])
-    check = klass.constantize.new value, opts
-    check.value = check.default if check.value.nil?
+  # class_finder :user, :exporter, :representer
+  # find first UserExporter, User::Exporter, User::Representer, UserRepresenter
+  def class_finder *args
+    name = args.shift.to_s.classify
 
-    unless check.value.nil?
-      begin
-        check.set
-        check.validate
-        check.value
-      rescue TypeError => e
-        add_error field, e.message, opts
+    for el in args
+      for separator in ['_','/']
+        klass = [name, el].join(separator).classify
+        return klass.constantize if const_defined? klass
       end
     end
+
+    nil
   end
 end