typero 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1b145b43e7736b2c9f673b6685388a39ee83fcba0bbcbc0ad2fcf8af2c1f692
-  data.tar.gz: dd730a85ab31d2b181b875d7052e3b109a263caba0618d869e262e3004e6d52f
+  metadata.gz: 8e78c338c182793ab2bffd1b4c5469d5285f57f55697402b6e80fb1881a3f7a8
+  data.tar.gz: 18a803b38ef8a24cb3756a43e5b5704082a08f4d805be57239cb054c28e6f132
 SHA512:
-  metadata.gz: 86b7d2a84fccf9d800ae9c121773d3ae960b6f2c32100466836d6f07056ad2f2affa4fdbe8df8c91ea5cc208d7e006db993ddbce86c30b9652077b87f22cd4c5
-  data.tar.gz: 95a83f6b58874de8b27edb08811ea9543ebe7036550364d535f1a73042af90d77e36a891ccfcab9db36817572e6a400c203356cc54fb929358730bfc8425999e
+  metadata.gz: 1c02d8cec42f465c5cf34b0b69c856cf193f1c5e289898af0aefdebf1d61ed91c95148a1fa9ca1c047a07810c99bd518946dbfe323e0e53c4502b66b08910c85
+  data.tar.gz: de185fca3ac80a4e7e9d6b87778872b3b352f89678f334e24b0047480d401cbd0abf95bb8940ba0e29d9d3f485ef62521b38335f1f6cc3a7d1f59194383f4a67

data/.version

@@ -1 +1 @@
-0.8.1
+0.9.0

data/lib/typero.rb

@@ -1,7 +1,8 @@
 # base libs
 require_relative 'typero/typero'
-require_relative 'typero/func'
+require_relative 'typero/schema'
 require_relative 'typero/params'
+require_relative 'typero/exporter'
 require_relative 'typero/type/type'
 
 # checker types

data/lib/typero/exporter.rb

@@ -0,0 +1,93 @@
+module Typero
+  class Exporter
+    EXPORTERS ||= {}
+
+    attr_accessor :response
+
+    def initialize model, opts={}
+      opts = { user: opts } unless opts.is_a?(Hash)
+
+      opts[:exporter]      ||= model.class
+      opts[:depth]         ||= 1
+      opts[:current_depth] ||= 0
+
+      exporter = opts.delete(:exporter).to_s.classify
+
+      @model    = model
+      @opts     = opts
+      @block    = EXPORTERS[exporter] || raise('Exporter "%s" (:%s) not found' % [block, block.underscore])
+      @response = {}
+    end
+
+    def render
+      instance_exec &@block
+      @response
+    end
+
+    private
+
+    def export object, opts={}
+      if object.is_a?(Symbol)
+        return property object, export(model.send(object))
+      end
+
+      return if @opts[:current_depth] >= @opts[:depth]
+
+      @opts[:current_depth] += 1
+      out = self.class.new(object, @opts.merge(opts)).render
+      @opts[:current_depth] -= 1
+      out
+    end
+
+    def property name, data=:_undefined
+      if block_given?
+        data = yield if data == :_undefined
+        @response[name] = data
+      else
+        data = data == :_undefined ? model.send(name) : data
+
+        if data.respond_to?(:export_json)
+          data = data.export_json
+        elsif data.respond_to?(:to_h)
+          data = data.to_h
+        end
+
+        @response[name] = data
+      end
+    end
+    alias :prop :property
+
+    def hproperty name
+      @response[name] = model[name]
+    end
+    alias :hprop :hproperty
+
+    def namespace name, &block
+
+    end
+
+    def meta &block
+      namespace :meta, &block
+    end
+
+    def model
+      @model
+    end
+
+    # get current user from globals if globals defined
+    def user
+      if @opts[:user]
+        @opts[:user]
+      elsif defined?(User) && User.respond_to?(:current)
+        User.current
+      elsif defined?(Current) && Current.respond_to?(:user)
+        Current.user
+      elsif current_user = Thread.current[:current_user]
+        current_user
+      else
+        nil
+      end
+    end
+  end
+end
+

data/lib/typero/params.rb

@@ -1,9 +1,7 @@
 # Base class for schema validation
 
-class Typero
+module 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
@@ -25,8 +23,7 @@ class Typero
         opts[:type] ||= args[0]
       end
 
-      opts[:type]   ||= :string
-      opts[:required] = true unless opts[:required].is_a?(FalseClass) || opts[:req].is_a?(FalseClass)
+      opts[:type] = :string if opts[:type].nil?
 
       field = field.to_s
 
@@ -36,6 +33,8 @@ class Typero
         opts[:required] = false
       end
 
+      opts[:required] = true if opts[:required].nil?
+
       # array that allows duplicates
       if opts[:type].is_a?(Array)
         opts[:type]  = opts[:type].first
@@ -48,20 +47,36 @@ class Typero
         opts[:array] = true
       end
 
+      # Boolean
+      if opts[:type].is_a?(TrueClass)
+        opts[:required] = false
+        opts[:default]  = true
+        opts[:type]     = :boolean
+      elsif opts[:type].is_a?(FalseClass)
+        opts[:required] = false
+        opts[:default]  = false
+        opts[:type]     = :boolean
+      end
+
+      opts[:model] = opts.delete(:schema) if opts[:schema]
+      opts[:type]  = :model if opts[:model]
+
       opts[:type] ||= 'string'
-      opts[:type]   = opts[:type].to_s.downcase
+      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
-      result = opts.keys - ALLOWED
-      raise ArgumentError.new('Unallowed Type params found: %s, allowed: %s' % [result.join(', '), ALLOWED]) if result.length > 0
+      result = opts.keys - Typero::Type::OPTS_KEYS
+      raise ArgumentError.new('Unallowed Type params found: "%s", allowed: %s' % [result.join(' and '), Typero::Type::OPTS_KEYS.sort]) if result.length > 0
 
       field = field.to_sym
 
       db :add_index, field if opts.delete(:index)
 
-      klass = Typero::Type.load opts[:type]
+      # trigger error if type not found
+      Typero::Type.load opts[:type]
+
       @rules[field] = opts
     end
 

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

@@ -1,6 +1,6 @@
 # Master class
 
-class Typero
+module Typero
   class Type
     ERRORS = {
       en: {
@@ -9,14 +9,16 @@ class Typero
         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'
+        unallowed_characters_error: 'is having unallowed characters',
+        not_in_range: 'Value in not in allowed range (%s)'
       }
     }
 
-    OPTS = {}
+    # default shared allowed opts keys
+    OPTS_KEYS = [:type, :required, :array, :max_count, :default, :name, :meta, :model]
+    OPTS      = {}
 
-    attr_accessor :opts
-    attr_accessor :value
+    attr_reader :opts
 
     class << self
       def load name
@@ -36,6 +38,8 @@ class Typero
       end
 
       def opts key, desc
+        OPTS_KEYS.push key unless OPTS_KEYS.include?(key)
+
         OPTS[self] ||= {}
         OPTS[self][key] = desc
       end
@@ -43,20 +47,44 @@ class Typero
 
     ###
 
-    def initialize value, opts={}
+    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
 
-    # default validation for any type
-    def validate
-      true
+    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

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
+