typero 0.4.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2abbf2baf5e54e738a8144eba2aa35218d88faaf1f26032a041474df61ebc393
-  data.tar.gz: 5d0eed00df648f251b43148b185dab5f05b07068ed225d831584e5a831d41b8a
+  metadata.gz: 8e78c338c182793ab2bffd1b4c5469d5285f57f55697402b6e80fb1881a3f7a8
+  data.tar.gz: 18a803b38ef8a24cb3756a43e5b5704082a08f4d805be57239cb054c28e6f132
 SHA512:
-  metadata.gz: 78c673d3df0f2a968f44f9fab440c11831de686684d505ac3224ac937a470b0a773c1353a4c37eeb703fdf00fa13dab0a799f59e5ff5596ef75ab32860c0a9b4
-  data.tar.gz: 735f2eea8437315bf330e9d31f7e3fd9b910b3da8b7c9a3792e9b06f4628789798a4aeef089064baac2db412a0fefbeb948908c50bccb4ee6fdfba9497c8f0d4
+  metadata.gz: 1c02d8cec42f465c5cf34b0b69c856cf193f1c5e289898af0aefdebf1d61ed91c95148a1fa9ca1c047a07810c99bd518946dbfe323e0e53c4502b66b08910c85
+  data.tar.gz: de185fca3ac80a4e7e9d6b87778872b3b352f89678f334e24b0047480d401cbd0abf95bb8940ba0e29d9d3f485ef62521b38335f1f6cc3a7d1f59194383f4a67

data/.version

@@ -1 +1 @@
-0.4.0
+0.9.0

data/lib/adapters/sequel.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sequel::Plugins::TyperoAttributes
+  module ClassMethods
+    def typero
+      Typero.new self
+    end
+  end
+
+  module InstanceMethods
+    # calling typero! on any object will validate all fields
+    def typero! field_name=nil
+      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)
+      end
+
+      # this are rules unique to database, so we check them here
+      typero.rules.each do |field, rule|
+        self[field] ||= {} if rule[:type] == 'hash'
+
+        # check uniqe fields
+        if rule[:unique]
+          id    = self[:id] || 0
+          value = self[field]
+
+          # we only check if field is changed
+          if value.present? && column_changed?(field) && self.class.xwhere('LOWER(%s)=LOWER(?) and id<>?' % field, value, id).first
+            error = rule[:unique].class == TrueClass ? %[Value '"#{value}"' for #{field} allready exists] : rule[:unique]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+
+        # check protected fields
+        if rule[:protected] && self[:id]
+          if column_changed?(field)
+            error = rule[:protected].class == TrueClass ? "value once defined can't be overwritten." : rule[:protected]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+      end
+
+      # check single field if single field given
+      if field_name
+        raise ArgumentError.new 'Field :%s not found in %s' % [field_name, self] unless self[field_name]
+        return unless errors.on(field_name)
+
+        errors.on(field_name).join(', ')
+      end
+
+      true
+    end
+
+    def validate
+      typero!
+      super
+    end
+  end
+
+  module DatasetMethods
+
+  end
+end
+
+Sequel::Model.plugin :typero_attributes
+

data/lib/typero.rb

@@ -1,172 +1,14 @@
-# rules = Typero.new do
-#   set :name, String, req: true
-#   set :email, :email, req: true
-#   set :skills, [:email], min: 2
-# end
-#
-# or
-#
-# rules = Typero.new do
-#   string :name, req: true
-#   email :email, req: true
-#   email [:skills], min: 2
-# end
-#
-# errors = rules.validate @object
-# rules.valid?
-# rules.validate(@object) { |errors| ... }
-
-class Typero
-  attr_reader :rules
-
-  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
-      rule.set field, type, opts
-
-      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={}
-      check = Typero::Type.load(type).new value, opts
-      check.set
-    end
-  end
-
-  ###
-
-  # accepts dsl block to
-  def initialize hash={}, &block
-    @rules = {}
-    hash.each { |k, v| set(k, v) }
-    instance_exec &block if block
-  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
-
-    set field, type=name, *args
-  end
-
-  # coerce opts values
-  def parse_option opts
-    opts[:type] ||= 'string'
-    opts[:req] = opts.delete(:required) unless opts[:required].nil?
-
-    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[:req]  unless opts[:req].nil?
-    opts[:unique]      = opts[:uniq] unless opts[:uniq].nil?
-    opts[:description] = opts[:desc] unless opts[:desc].nil?
-
-    # allowed_names = [:req, :uniq, :protected, :type, :min, :max, :array_type, :default, :downcase, :desc, :label]
-    # opts.keys.each do |key|
-    #   raise ArgumentError.new('%s is not allowed as typero option' % key) unless allowed_names.index(key)
-    # end
-
-    opts
-  end
-
-  # used in dsl to define value
-  def set field, type=String, opts={}
-    opts = type.is_a?(Hash) ? type : opts.merge(type: type)
-
-    opts[:type] ||= :string
-    klass = Typero::Type.load opts[:type]
-    @rules[field] = parse_option opts
-  end
-
-  def safe_type type
-    type.to_s.gsub(/[^\w]/,'').classify
-  end
-
-  # adds error to array or prefixes with field name
-  def add_error field, msg
-    if @errors[field]
-      @errors[field] += ', %s' % msg
-    else
-      if msg[0,1].downcase == msg[0,1]
-        field_name = field.to_s.sub(/_id$/,'').humanize
-        msg = '%s %s' % [field_name, msg]
-      end
-
-      @errors[field] = msg
-    end
-  end
-
-  # validates any instance object or object with hash variable interface
-  # it also coarces values
-  def validate instance
-    @errors = {}
-
-    @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?
-
-      # 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
-        end
-      elsif opts[:required]
-        msg = opts[:required].class == TrueClass ? 'is required' : opts[:req]
-        add_error field, msg
-      end
-    end
-
-    if @errors.keys.length > 0 && block_given?
-      @errors.each { |k,v| yield(k, v) }
-    end
-
-    @errors
-  end
-
-  def valid? instance
-    errors = validate instance
-    errors.keys.length == 0
-  end
+# base libs
+require_relative 'typero/typero'
+require_relative 'typero/schema'
+require_relative 'typero/params'
+require_relative 'typero/exporter'
+require_relative 'typero/type/type'
+
+# checker types
+Dir['%s/typero/type/types/*.rb' % __dir__].each do |file|
+  require file
 end
 
-require_relative 'typero/type'
-
-Dir['%s/typero/type/*.rb' % File.dirname(__FILE__)].each { |file| require file }
+# load Sequel adapter is Sequel is available
+require_relative './adapters/sequel' if defined?(Sequel)

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

@@ -0,0 +1,99 @@
+# Base class for schema validation
+
+module Typero
+  class Params
+    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 if opts[:type].nil?
+
+      field = field.to_s
+
+      # name? - opional name
+      if field.include?('?')
+        field = field.sub('?', '')
+        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
+        opts[:array] = true
+      end
+
+      # no duplicates array
+      if opts[:type].is_a?(Set)
+        opts[:type]  = opts[:type].to_a.first
+        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.to_sym
+
+      opts[:description] = opts.delete(:desc) unless opts[:desc].nil?
+
+      # chek alloed params, all optional should go in meta
+      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)
+
+      # trigger error if type not found
+      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