typero 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 448ffb9631eeb66159f13e45da0e28e600f91f3ed58684789740f2ad351a317b
-  data.tar.gz: 41feafdf4c139e47c02dc71c0c5dbdea154b6e75e0b8a746e1b7f41c6beb89d6
+  metadata.gz: ba656a56b8d2e5d3d977a2973f6de881eefd3257397a4a4ebe908a7abaed70a7
+  data.tar.gz: 8374f340b6af235c274ceaa9aace33f0c462b5a203d667a199fa519c1f56f53e
 SHA512:
-  metadata.gz: 28c28657d7a0c7c5e71b5cfac08eb314a857c9b4e01337666ab38f65c64aa99f1c07a56d3276f8446e0134bc28968b7b34fb13232769c97ed01c6847cdab657e
-  data.tar.gz: 65f56f37df4731adad738862fdb79ed540bdd22a3a85744f519370e4ae5d905bafa74ab4720d17d6916c068a4f9508225d20cde64a6735c29a9f9e978a9ef145
+  metadata.gz: ba14e29595a5d17c3c3d102f49d1234a82e7ea23a7062a4a61c6dc56770d9d4922f1be7ae01663c41382efb6c6c51ed3fb5dfd4c188315ec1a5bf3f43eb699fc
+  data.tar.gz: c2d8b322fac4048067b809bf7944c8ca27bb787d4b590a68eec62169a768a65ddbb089359da73f550a32b59a0405b95629ae4932bf7a3dfb9d5426e2e26d3e7d

data/.version

@@ -1 +1 @@
-0.7.0
+0.8.0

data/lib/adapters/sequel.rb

@@ -2,13 +2,17 @@
 
 module Sequel::Plugins::TyperoAttributes
   module ClassMethods
-    attr_accessor :typero
+    def typero
+      Typero.new self
+    end
   end
 
   module InstanceMethods
     # calling typero! on any object will validate all fields
     def typero! field_name=nil
-      typero = self.class.typero || return
+      return unless Typero.defined?(self.class)
+
+      typero = self.class.typero
 
       typero.validate(self) do |name, err|
         errors.add(name, err) unless (errors.on(name) || []).include?(err)

data/lib/typero.rb

@@ -1,10 +1,10 @@
 # base libs
 require_relative 'typero/typero'
-require_relative 'typero/schema'
-require_relative 'typero/type'
+require_relative 'typero/params'
+require_relative 'typero/type/type'
 
 # checker types
-Dir['%s/typero/type/*.rb' % __dir__].each do |file|
+Dir['%s/typero/type/types/*.rb' % __dir__].each do |file|
   require file
 end
 

data/lib/typero/params.rb

@@ -0,0 +1,84 @@
+# Base class for schema validation
+
+class Typero
+  class Params
+    ALLOWED = %i(name min max default allowed delimiter max_count req required type array meta desc description duplicates unique)
+
+    attr_reader :rules, :db_rules
+
+    def initialize &block
+      @db_rules = []
+      @rules    = {}
+      instance_exec &block
+    end
+
+    private
+
+    # used in dsl to define schema field options
+    def set field, *args
+      raise "Field name not given (Typero)" unless field
+
+      if args.first.is_a?(Hash)
+        opts = args.first || {}
+      else
+        opts = args[1] || {}
+        opts[:type] ||= args[0]
+      end
+
+      opts[:type]   ||= :string
+      opts[:required] = true unless opts[:required].is_a?(FalseClass) || opts[:req].is_a?(FalseClass)
+
+      field = field.to_s
+
+      # name? - opional name
+      if field.include?('?')
+        field = field.sub('?', '')
+        opts[:required] = false
+      end
+
+      # array that allows duplicates
+      if opts[:type].is_a?(Array)
+        opts[:type]  = opts[:type].first
+        opts[:array] = true
+      end
+
+      # no duplicates array
+      if opts[:type].is_a?(Set)
+        opts[:type]  = opts[:type].to_a.first
+        opts[:array] = true
+      end
+
+      opts[:type] ||= 'string'
+      opts[:type]   = opts[:type].to_s.downcase
+
+      opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
+
+      # chek alloed params, all optional should go in meta
+      result = opts.keys - ALLOWED
+      raise ArgumentError.new('Unallowed Type params found: %s, allowed: %s' % [result.join(', '), ALLOWED]) if result.length > 0
+
+      field = field.to_sym
+
+      db :add_index, field if opts.delete(:index)
+
+      klass = 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
+    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
+    end
+  end
+end

data/lib/typero/type/type.rb

@@ -0,0 +1,82 @@
+# Master class
+
+class 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'
+      }
+    }
+
+    OPTS = {}
+
+    attr_accessor :opts
+    attr_accessor :value
+
+    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[self] ||= {}
+        OPTS[self][key] = desc
+      end
+    end
+
+    ###
+
+    def initialize value, opts={}
+      @value = value
+      @opts  = opts
+    end
+
+    # default validation for any type
+    def validate
+      true
+    end
+
+    def default
+      nil
+    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/{currency.rb → types/currency.rb}

@@ -1,3 +1,5 @@
+# you should not use this filed for currency calculations
+
 require_relative './float'
 
 class Typero::CurrencyType < Typero::FloatType

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

@@ -0,0 +1,21 @@
+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 = @value.downcase.gsub(/\s+/,'+')
+  end
+
+  def validate
+    error_for(:not_8_chars_error) unless @value.to_s.length > 7
+    error_for(:missing_monkey_error) unless @value.include?('@')
+  end
+
+  def db_field
+    opts = {}
+    opts[:limit] = @opts[:max] || 120
+    opts[:null]  = false if @opts[:required]
+    [:string, opts]
+  end
+end
+

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

@@ -0,0 +1,21 @@
+class Typero::FloatType < Typero::Type
+  opts :min, 'Minimum value'
+  opts :max, 'Maximun value'
+
+  def set
+    @value = @value.to_f
+  end
+
+  def validate
+    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_field
+    opts = {}
+    opts[:null] = false if @opts[:required]
+    [:float, opts]
+  end
+
+end
+

data/lib/typero/type/{hash.rb → types/hash.rb}

@@ -1,4 +1,6 @@
 class Typero::HashType < Typero::Type
+  error :en, :not_hash_type_error, 'value is not hash type'
+
   def default
     {}
   end
@@ -8,11 +10,7 @@ class Typero::HashType < Typero::Type
   end
 
   def validate
-    raise TypeError, error_for(:not_hash_type_error) unless @value.is_a?(Hash)
-  end
-
-  def not_hash_type_error
-    'value is not hash type'
+    error_for(:not_hash_type_error) unless @value.is_a?(Hash)
   end
 
   def db_field

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

@@ -0,0 +1,28 @@
+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
+    @value = 'https://%s' % @value unless @value.include?('://')
+  end
+
+  def validate
+    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_field
+    opts = {}
+    opts[:null] = false if @opts[:required]
+    [:string, opts]
+  end
+end
+

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

@@ -0,0 +1,21 @@
+class Typero::IntegerType < Typero::Type
+  opts :min, 'Minimum value'
+  opts :max, 'Maximun value'
+
+  def set
+    @value = @value.to_i
+  end
+
+  def validate
+    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_field
+    opts = {}
+    opts[:null]    = false if @opts[:required]
+    opts[:default] = @opts[:default]
+    [:integer, opts]
+  end
+end
+

data/lib/typero/type/{label.rb → types/label.rb}

@@ -4,11 +4,7 @@ class Typero::LabelType < Typero::Type
   end
 
   def validate
-    raise TypeError, error_for(:unallowed_characters_error) unless @value =~ /^[\w\-]+$/
-  end
-
-  def unallowed_characters_error
-    'label is having unallowed characters'
+    error_for(:unallowed_characters_error) unless @value =~ /^[\w\-]+$/
   end
 
   def db_field

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

@@ -1,4 +1,23 @@
 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)
+  end
+
+  def db_field
+    opts = {}
+    opts[:null]  = false if @opts[:required]
+    opts[:limit] = 11
+    [:string, opts]
+  end
+
+  private
+
   # http://domagoj.eu/oib/
   def check? oib
     oib = oib.to_s
@@ -19,23 +38,5 @@ class Typero::OibType < Typero::Type
     return control_sum == oib.at(10).to_i
   end
 
-  def set
-    @value = check?(@value) ? @value.to_i : nil
-  end
-
-  def validate
-    raise TypeError.new(error_for(:not_an_oib_error)) unless check?(@value)
-  end
-
-  def not_an_oib_error
-    'not in an OIB format'
-  end
-
-  def db_field
-    opts = {}
-    opts[:null]  = false if @opts[:required]
-    opts[:limit] = 11
-    [:string, opts]
-  end
 end
 

data/lib/typero/type/{point.rb → types/point.rb}

@@ -3,7 +3,6 @@
 
 class Typero::PointType < Typero::Type
   def set
-    ap @value
     if @value.present?
       if @value.include?('/@')
         point = @value.split('/@', 2).last.split(',')
@@ -19,13 +18,12 @@ class Typero::PointType < Typero::Type
 
   def validate
     if @value && @value.include?(',') && !@value =~ /^SRID=4326;POINT\(/
-      raise TypeError, error_for(:unallowed_characters_error)
+      error_for(:unallowed_characters_error)
     end
   end
 
   def db_field
     [:geography, {}]
   end
-
 end
 

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

@@ -0,0 +1,23 @@
+class Typero::StringType < Typero::Type
+  opts :min, 'Minimun string length'
+  opts :max, 'Maximun string length'
+
+  def set
+    @value = @value.to_s unless @value.is_a?(String)
+    @value = @value.downcase if @opts[:downcase]
+  end
+
+  def validate
+    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_field
+    opts = {}
+    opts[:limit]   = @opts[:max] || 255
+    opts[:null]    = false if @opts[:required]
+    opts[:default] = @opts[:default]
+    [:string, opts]
+  end
+end
+

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

@@ -1,6 +1,9 @@
 require_relative 'string'
 
 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]

data/lib/typero/type/{url.rb → types/url.rb}

@@ -1,14 +1,12 @@
 class Typero::UrlType < Typero::Type
+  error :en, :url_not_starting_error, 'URL is not starting with http'
+
   def set
     @value = 'http://%s' % @value unless @value.include?('://')
   end
 
   def validate
-    raise TypeError, error_for(:not_starting_error) unless @value =~ /^https?:\/\/./
-  end
-
-  def not_starting_error
-    'URL is not starting with http'
+    error_for(:url_not_starting_error) unless @value =~ /^https?:\/\/./
   end
 
   def db_field

data/lib/typero/typero.rb

@@ -17,127 +17,100 @@
 # rules.validate(@object) { |errors| ... }
 
 class Typero
-  SCHEMAS = {}
-  VERSION = File.read File.expand_path '../../.version', File.dirname(__FILE__)
+  VERSION = File.read File.expand_path "../../.version", File.dirname(__FILE__)
 
   class << self
-    # validate single value in type
-    def validate type, value, opts={}
-      field = type.to_s.tableize.singularize.to_sym
-
-      # we need to have pointer to hash, so value can be changed (coerced) if needed
-      h = { field => value }
-
-      rule = new do
-        set field, type, opts
-      end
-
-      if error = rule.validate(h)[field]
-        block_given? ? yield(error) : raise(TypeError.new(error))
-      end
-
-      h[field]
-    end
-
     # check and coerce value
     # Typero.set(:label, 'Foo bar') -> "foo-bar"
-    def set type, value, opts={}
+    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
-
-    # list loaded classes
-    def list type=nil
-      SCHEMAS
-        .select { |k, v| type ? v[1] == type : true; }
-        .keys
-    end
-
-    # def schema table_name, &block
-    #   schema = Typero.new(&block)
-
-    #   if Lux.config.migrate
-    #     AutoMigrate.typero table_name, schema
-    #   else
-    #     klass = table_name.to_s.classify.constantize
-    #     klass.typero = schema
-    #   end
-    # end
   end
 
   ###
 
   # accepts dsl block to
-  def initialize name=nil, &block
-    type = :default
-
-    if name.is_a?(Hash)
-      type = name.keys.first
-      name = name.values.first
-    end
-
-    if block_given?
-      @schema = Schema.new &block
-
-      if name
-         SCHEMAS[name_fix(name)] = [@schema, type]
-      end
-    elsif name
-      schema_name = name_fix(name)
-      @schema = SCHEMAS[schema_name][0] || raise(ArgumentError.new('Schema nemed "%s" not found (%s)' % [schema_name, name]))
-    else
-      raise ArgumentError, 'No block or schema name given'
-    end
+  def initialize &block
+    raise "Params not defined" unless block_given?
+    @schema = Params.new &block
   end
 
-  # validates any instance object or object with hash variable interface
+  # validates any instance object with hash variable interface
   # it also coarces values
-  def validate instance
+  def validate object
+    @object = object
     @errors = {}
 
     @schema.rules.each do |field, opts|
       # set value to default if value is blank and default given
-      instance[field] = opts[:default] if opts[:default] && instance[field].blank?
+      @object[field] = opts[:default] if opts[:default] && @object[field].blank?
 
       # get field value
-      value = instance[field]
-
-      if value.present?
-        klass = 'Typero::%sType' % safe_type(opts[:type])
-        check = klass.constantize.new value, opts
-        check.value = check.default if check.value.nil?
-
-        unless check.value.nil?
-          begin
-            check.set
-            check.validate
-            instance[field] = check.value
-          rescue TypeError => e
-            add_error field, e.message
-          end
+      value = @object[field]
+
+      if opts[:array]
+        unless value.is_a?(Array)
+          opts[:delimiter] ||= /\s*,\s*/
+          value = value.to_s.split(opts[:delimiter])
         end
-      elsif opts[:required]
-        msg = opts[:required].class == TrueClass ? 'is required' : opts[:required]
-        add_error field, msg
+
+        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) }
+      @errors.each { |k, v| yield(k, v) }
     end
 
     @errors
   end
 
-  def valid? instance
-    errors = validate instance
+  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)|
-      type, opts = Typero::Type.load(opts[:type]).new(nil, opts).db_field
+      # 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
 
@@ -149,27 +122,25 @@ class Typero
   # iterate trough all the ruels via block interface
   # schema.rules do |field, opts|
   # schema.rules(:url) do |field, opts|
-  def rules filter=nil, &block
+  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
+    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?
 
-    for k, v in out
-      yield k, v
-    end
+    out.each { |k, v| yield k, v }
   end
 
   private
 
   # adds error to array or prefixes with field name
-  def add_error field, msg
+  def add_error field, msg, opts
     if @errors[field]
-      @errors[field] += ', %s' % msg
+      @errors[field] += ", %s" % msg
     else
-      if msg && msg[0,1].downcase == msg[0,1]
-        field_name = field.to_s.sub(/_id$/,'').humanize
-        msg = '%s %s' % [field_name, msg]
+      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
@@ -177,15 +148,30 @@ class Typero
   end
 
   def safe_type type
-    type.to_s.gsub(/[^\w]/,'').classify
+    type.to_s.gsub(/[^\w]/, "").classify
   end
 
-  def name_fix name
-    if name.is_a?(Symbol)
-      name.to_s.classify if name.is_a?(Symbol)
-    else
-      name.to_s
+  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
+
+  def check_filed_value field, value, opts
+    return unless value
+
+    klass = "Typero::%sType" % safe_type(opts[:type])
+    check = klass.constantize.new value, opts
+    check.value = check.default if check.value.nil?
+
+    unless check.value.nil?
+      begin
+        check.set
+        check.validate
+        check.value
+      rescue TypeError => e
+        add_error field, e.message, opts
+      end
     end
   end
 end
-

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Dino Reic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-29 00:00:00.000000000 Z
+date: 2020-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fast_blank
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0'
 description: Simple and fast ruby type system. Enforce types as Array, Email, Boolean
   for ruby class instances
 email: reic.dino@gmail.com
@@ -34,24 +34,23 @@ files:
 - "./.version"
 - "./lib/adapters/sequel.rb"
 - "./lib/typero.rb"
-- "./lib/typero/schema.rb"
-- "./lib/typero/type.rb"
-- "./lib/typero/type/array.rb"
-- "./lib/typero/type/boolean.rb"
-- "./lib/typero/type/currency.rb"
-- "./lib/typero/type/date.rb"
-- "./lib/typero/type/datetime.rb"
-- "./lib/typero/type/email.rb"
-- "./lib/typero/type/float.rb"
-- "./lib/typero/type/hash.rb"
-- "./lib/typero/type/image.rb"
-- "./lib/typero/type/integer.rb"
-- "./lib/typero/type/label.rb"
-- "./lib/typero/type/oib.rb"
-- "./lib/typero/type/point.rb"
-- "./lib/typero/type/string.rb"
-- "./lib/typero/type/text.rb"
-- "./lib/typero/type/url.rb"
+- "./lib/typero/params.rb"
+- "./lib/typero/type/type.rb"
+- "./lib/typero/type/types/boolean.rb"
+- "./lib/typero/type/types/currency.rb"
+- "./lib/typero/type/types/date.rb"
+- "./lib/typero/type/types/datetime.rb"
+- "./lib/typero/type/types/email.rb"
+- "./lib/typero/type/types/float.rb"
+- "./lib/typero/type/types/hash.rb"
+- "./lib/typero/type/types/image.rb"
+- "./lib/typero/type/types/integer.rb"
+- "./lib/typero/type/types/label.rb"
+- "./lib/typero/type/types/oib.rb"
+- "./lib/typero/type/types/point.rb"
+- "./lib/typero/type/types/string.rb"
+- "./lib/typero/type/types/text.rb"
+- "./lib/typero/type/types/url.rb"
 - "./lib/typero/typero.rb"
 homepage: https://github.com/dux/typero
 licenses:

data/lib/typero/schema.rb

@@ -1,84 +0,0 @@
-# Base class for schema validation
-
-class Typero
-  class Schema
-    attr_reader :rules, :db_rules
-
-    def initialize &block
-      @db_rules = []
-      @rules    = {}
-      instance_exec &block
-    end
-
-    private
-
-    # used in dsl to define value
-    def set field, type=String, opts={}
-      raise "Field name not given (Typero)" unless field
-
-      field = field.to_sym
-      opts  = type.is_a?(Hash) ? type : opts.merge(type: type)
-      opts[:type]   ||= :string
-      opts[:required] = true if opts[:null].class == FalseClass
-
-      db :add_index, field if opts.delete(:index)
-
-      klass = Typero::Type.load opts[:type]
-      @rules[field] = parse_option opts
-    end
-
-    # coerce opts values
-    def parse_option opts
-      opts[:type] ||= 'string'
-
-      if opts[:type].is_a?(Array)
-         opts[:array_type] = opts[:type][0] if opts[:type][0]
-         opts[:type] = 'array'
-      end
-
-      opts[:type] = opts[:type].to_s.downcase
-
-      opts[:required]    = opts.delete(:req)  unless opts[:req].nil?
-      opts[:unique]      = opts.delete(:uniq) unless opts[:uniq].nil?
-      opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
-
-      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
-
-    def link klass, opts={}
-      klass.is! Class
-
-      # TODO: Add can? update check before save
-      integer '%s_id' % klass.to_s.tableize.singularize, opts
-    end
-
-    def hash name
-      set name, :hash
-    end
-
-    # set :age, type: :integer -> integer :age
-    # email :email
-    # set :email, [:emails]
-    # email [:emails]
-    def method_missing name, *args, &block
-      field = args.shift
-
-      if field.class == Array
-        field = field.first
-        name  = [name]
-      end
-
-      name = args.shift if name == :set
-
-      set field, type=name, *args
-    end
-
-  end
-end

data/lib/typero/type.rb

@@ -1,43 +0,0 @@
-# Master class
-
-class Typero
-  class Type
-    attr_accessor :opts
-    attr_accessor :value
-
-    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
-    end
-
-    ###
-
-    def initialize value, opts={}
-      @value = value
-      @opts  = opts
-    end
-
-    # default validation for any type
-    def validate
-      true
-    end
-
-    # get error from option or the default one
-    def error_for name
-      @opts[name] || send(name)
-    end
-
-    def default
-      nil
-    end
-  end
-end
-
-

data/lib/typero/type/array.rb

@@ -1,55 +0,0 @@
-class Typero::ArrayType < Typero::Type
-  def default
-    []
-  end
-
-  def set
-    unless @value.class.to_s.index('Array')
-      @value = @value.to_s.sub(/^\{/,'').sub(/\}$/,'')
-
-      # split on new line and comma by default
-      @value = @value.split(/\s*[,\n]\s*/)
-    end
-
-    @value.uniq!
-    @value.compact!
-
-    if type = @opts[:array_type]
-      @value.map! { |el|
-        Typero.validate(type, el) { |msg|
-          raise TypeError.new "'%s' %s (%s)" % [el, msg, value_in_list_error]
-        }
-      }
-    end
-
-    # this converts Sequel::Postgres::PGArray to Array and fixes many problems
-    @value = @value.to_a if @value.class != Array
-  end
-
-  def validate
-    raise TypeError, error_for(:min_error) % @opts[:min] if @opts[:min] && @value.length < @opts[:min]
-    raise TypeError, error_for(:max_error) % @opts[:max] if @opts[:max] && @value.length > @opts[:max]
-    true
-  end
-
-  def min_error
-    'min array lenght is %s elements'
-  end
-
-  def max_error
-    'max array lenght is %s elements'
-  end
-
-  def value_in_list_error
-    'value in list'
-  end
-
-  def db_field
-    check  = Typero::Type.load(@opts[:array_type]).new nil, {}
-    schema = check.db_field
-    schema[1] ||= {}
-    schema[1].merge! array: true
-    schema
-  end
-end
-

data/lib/typero/type/email.rb

@@ -1,27 +0,0 @@
-class Typero::EmailType < Typero::Type
-
-  def set
-    @value = @value.downcase.gsub(/\s+/,'+')
-  end
-
-  def validate
-    raise TypeError, error_for(:not_8_chars_error) unless @value.to_s.length > 7
-    raise TypeError, error_for(:missing_monkey_error) unless @value.include?('@')
-  end
-
-  def not_8_chars_error
-    'is not having at least 8 characters'
-  end
-
-  def missing_monkey_error
-    'is missing @'
-  end
-
-  def db_field
-    opts = {}
-    opts[:limit] = @opts[:max] || 120
-    opts[:null]  = false if @opts[:required]
-    [:string, opts]
-  end
-end
-

data/lib/typero/type/float.rb

@@ -1,27 +0,0 @@
-class Typero::FloatType < Typero::Type
-
-  def set
-    @value = @value.to_f
-  end
-
-  def validate
-    raise TypeError, error_for(:min_length_error) % @opts[:min] if @opts[:min] && value < @opts[:min]
-    raise TypeError, error_for(:max_length_error) % @opts[:max] if @opts[:max] && value > @opts[:max]
-  end
-
-  def min_length_error
-    "min lenght is %s"
-  end
-
-  def max_length_error
-    "max lenght is %s"
-  end
-
-  def db_field
-    opts = {}
-    opts[:null] = false if @opts[:required]
-    [:float, opts]
-  end
-
-end
-

data/lib/typero/type/image.rb

@@ -1,28 +0,0 @@
-class Typero::ImageType < Typero::Type
-  # FORMATS = %w[jpg jpeg gif png svg]
-
-  def set
-    @value = 'https://%s' % @value unless @value.include?('://')
-  end
-
-  def validate
-    raise TypeError, error_for(:not_starting_error) unless @value =~ /^https?:\/\/./
-    # ext = @value.split('.').last.downcase
-    # raise TypeError, error_for(:not_image_format) unless FORMATS.include?(ext)
-  end
-
-  def not_starting_error
-    'URL is not starting with http'
-  end
-
-  # def not_image_format
-  #   'URL is not ending with %s' % FORMATS.join(', ')
-  # end
-
-  def db_field
-    opts = {}
-    opts[:null] = false if @opts[:required]
-    [:string, opts]
-  end
-end
-

data/lib/typero/type/integer.rb

@@ -1,26 +0,0 @@
-class Typero::IntegerType < Typero::Type
-  def set
-    @value = @value.to_i
-  end
-
-  def validate
-    raise TypeError, error_for(:min_value_error) % [@opts[:min], @value] if @opts[:min] && @value < @opts[:min]
-    raise TypeError, error_for(:max_value_error) % [@opts[:max], @value] if @opts[:max] && @value > @opts[:max]
-  end
-
-  def min_value_error
-    'min is %s, got %s'
-  end
-
-  def max_value_error
-    'max is %s, got %s'
-  end
-
-  def db_field
-    opts = {}
-    opts[:null]    = false if @opts[:required]
-    opts[:default] = @opts[:default]
-    [:integer, opts]
-  end
-end
-

data/lib/typero/type/string.rb

@@ -1,30 +0,0 @@
-class Typero::StringType < Typero::Type
-  def set
-    @value = @value.to_s unless @value.is_a?(String)
-    @value = @value.downcase if @opts[:downcase]
-  end
-
-  def validate
-    raise TypeError, error_for(:min_length_error) % [@opts[:min], @value.length] if @opts[:min] && @value.length < @opts[:min]
-    raise TypeError, error_for(:max_length_error) % [@opts[:max], @value.length] if @opts[:max] && @value.length > @opts[:max]
-  end
-
-  # ready for localization
-
-  def min_length_error
-    'min lenght is %s, you have %s'
-  end
-
-  def max_length_error
-    'max lenght is %s, you have %s'
-  end
-
-  def db_field
-    opts = {}
-    opts[:limit]   = @opts[:max] || 255
-    opts[:null]    = false if @opts[:required]
-    opts[:default] = @opts[:default]
-    [:string, opts]
-  end
-end
-