typero 0.8.1 → 0.9.0

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.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/model_type.rb

@@ -0,0 +1,21 @@
+class Typero::ModelType < Typero::Type
+  def set
+    value(&:to_h)
+
+    errors = []
+
+    schema = Typero.schema(opts[:model])
+    schema.validate(value) do |field, error|
+      errors.push '%s (%s)' % [error, field]
+    end
+
+    raise TypeError.new errors.join(', ') if errors.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,20 @@
+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]
+
+    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/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,161 +16,74 @@
 # rules.valid?
 # rules.validate(@object) { |errors| ... }
 
-class Typero
+module Typero
+  extend self
+
   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
+  # 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.get
+  rescue TypeError => error
+    if block
+      block.call error
+      false
+    else
+      raise error
     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
+  # load type schema
+  def schema name=nil, &block
+    # :user -> 'User'
+    name = name.to_s.classify if name
 
-        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
+    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
 
-      # 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]
+      schema   = Typero::Schema::SCHEMAS[name]
+      schema ||= class_finder name, :schema
+      schema || raise('Typero schema "%s" not defined' % name)
     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
+  def export model, opts={}, &block
+    if block_given?
+      Exporter::EXPORTERS[model.to_s.classify] = block
     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
+      Exporter.new(model, opts).render
     end
   end
 
-  def safe_type type
-    type.to_s.gsub(/[^\w]/, "").classify
+  def defined? name
+    Typero::Type.load name
+    true
+  rescue ArgumentError
+    false
   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
+  private
 
-  def check_filed_value field, value, opts
-    return unless value
+  # class_finder :user, :exporter, :representer
+  # find first UserExporter, User::Exporter, User::Representer, UserRepresenter
+  def class_finder *args
+    name = args.shift.to_s.classify
 
-    klass = "Typero::%sType" % safe_type(opts[:type])
-    check = klass.constantize.new value, opts
-    check.value = check.default if check.value.nil?
+    for el in args
+      for separator in ['_','/']
+        klass = [name, el].join(separator).classify
 
-    unless check.value.nil?
-      begin
-        check.set
-        check.validate
-        check.value
-      rescue TypeError => e
-        add_error field, e.message, opts
+        begin
+          return klass.constantize
+        rescue NameError => e
+          nil
+        end
       end
     end
   end