typero 0.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92cf598bbfb6f6b241b3f9d54e74ff8354f1a31c
-  data.tar.gz: 7d87b59b9fdee781f18ffebee6bfc161b81791a1
+  metadata.gz: 486d7ae19f1e96968faec9db6c8b37f99f8d24d7
+  data.tar.gz: de030fc9d1d929f6a8bfd8b8699dcd6ebc544051
 SHA512:
-  metadata.gz: 56d648431f62c1a64e47ac39f70e0cb305bef0ff261fae06d476b5d8abb20a3e03e59dccb217f19b265469738b0097f343ff908c35a60f307e47608f9bb838f8
-  data.tar.gz: 0339f991c56ca2690c74041e2559ac9501fedf3b5d85b5e88d11406fe3029e97ffbb697f1e1198c7e3df669c7928f81704f7c5b56d8d8446d1ff74bacec6098b
+  metadata.gz: 8612e66e0904743bedc0aa646f40004b4b82707b3cf74f3858d2588c223ccc9ac57c4a407b6f1ec3d5c2d7bcb31d26a9fd49477ec3c3c99e55bb3d52293498f8
+  data.tar.gz: ecd369fa535014e651faea154e010f23d5eaef43924a359692aef03a540ffb474235677991377cd131c03a3b99caa1cb59781fdd05a818acf404578bbc95e782

data/lib/typero.rb

@@ -1,3 +1,10 @@
+require_relative './typero/instance'
+require_relative './typero/schema'
+require_relative './typero/type'
+require_relative './typero/hash'
+
+Dir["#{File.dirname(__FILE__)}/typero/type/*.rb"].each{ |f| load f }
+
 # attribute :url, :url
 # attribute :name, req:'Link name is required'
 # attribute :tags, Array[:label]
@@ -81,9 +88,3 @@ module Typero
   end
 end
 
-require './lib/typero/instance'
-require './lib/typero/schema'
-require './lib/typero/type'
-require './lib/typero/hash'
-
-Dir['lib/typero/type/*.rb'].each{ |f| require "./#{f.sub('.rb','')}" }

data/lib/typero/hash.rb

@@ -0,0 +1,16 @@
+module Typero
+
+  # adds hash interface to models
+  module Hash
+    def [](k)
+      @attrs ||= {}
+      @attrs[k]
+    end
+
+    def []=(k,v)
+      @attrs ||= {}
+      @attrs[k] = v
+    end
+  end
+
+end

data/lib/typero/instance.rb

@@ -0,0 +1,52 @@
+module Typero
+  module Instance
+    def self.included(base)
+      def base.attribute(name, *args)
+        if !args[0]
+          opts = { type: :string }
+        elsif args[0].class.to_s == 'Hash'
+          if args[0].keys.length == 0
+            opts = { type: :hash }
+          else
+            type = args[0][:type] || :string
+            opts = args[0].merge( type: type )
+          end
+        elsif args[1]
+          opts = args[1]
+          opts[:type] = args[0]
+        else
+          opts = { type: args[0] }
+        end
+
+        if opts[:type].class.to_s == 'Array' && opts[:type][0] # Array[:email] -> array of emails
+          opts[:array_type] = opts[:type][0].to_s.downcase.to_sym
+          opts[:type] = :array
+        end
+
+        opts[:type]  = opts[:type].to_s.downcase.to_sym
+        opts[:type]  = :array if opts[:type] == :[]
+        opts[:req]   = "#{name.to_s.humanize.capitalize} is required" if opts[:req].class == TrueClass
+
+        Typero.define_instance(self, name, opts)
+      end
+    end
+
+    # def attributes=(opts)
+    #   for k,v in opts
+    #     send("#{k}=", v)
+    #   end
+    # end
+
+    def attribute_errors
+      # hash = InstanceAttributes.opts[self.class.to_s]
+      klass = self.class.to_s
+      opts = Typero.opts[klass]
+      return [] unless opts
+      errors = []
+      for k, v in opts
+        errors.push [k, v.opts[:req]] if v.opts[:req] && !v.present?(self[k])
+      end
+      errors
+    end
+  end
+end

data/lib/typero/schema.rb

@@ -0,0 +1,65 @@
+# validates hash against the schema
+# good if you can create validate objects and check against for function parameters
+# use whenever you want to check hash values of variables
+# in Lux FW, used in api cell
+
+module Typero
+  class Schema
+    class << self
+      # loads schema from hash and creates schema object
+      def load_schema(hash)
+        validate = new
+        for k,v in hash
+          validate.set(k,v)
+        end
+        validate
+      end
+    end
+
+    ###
+
+    def initialize
+      @check = {}
+    end
+
+    # set field values to check
+    # :age, Integer, { min:18, max:110 }
+    # :email, :email, { req:false }
+    def set(field, opts={}, &block)
+      opts[:req] ||= true unless opts[:req].class == FalseClass
+      opts[:func] = block if block_given?
+      opts[:type] ||= String
+      @check[field] = opts
+    end
+
+    # check agains hash of values { email:'dux@net.hr', age:'40' }
+    def check(hash)
+      errors = {}
+      for field in @check.keys
+        value = hash[field]
+        check_hash = @check[field]
+        type = check_hash[:type]
+
+        if value.blank? && check_hash[:req].class != FalseClass
+          errors[field] = check_hash[:req].kind_of?(String) ? check_hash[:req] : "#{field.to_s.capitalize} is required"
+          next
+        end
+
+        if check_hash[:func]
+          begin
+            check_hash[:func].call(value.to_s)
+          rescue
+            errors[field] = $!.message
+          end
+        elsif !Typero.validate(value, type)
+          errors[field] = "#{field.to_s.capitalize} is #{Typero.last_error}"
+        end
+      end
+      errors.keys.length > 0  ? errors : nil
+    end
+
+    def keys
+      @check.keys
+    end
+  end
+end

data/lib/typero/type.rb

@@ -0,0 +1,107 @@
+# str = Typero::StringType.new(req:true, default:'Miki')
+# str.set_value('Dino')
+# puts str.get_value
+
+# str = Typero::EmailType.new()
+# str.set_value('dux|at|dux.net') -> raises eror
+module Typero
+  class Type
+    attr_accessor :opts
+
+    ### SAFE TO OVERLOAD: START
+
+    # default min implementation
+    def min(value, length)
+      raise TypeError, "Min #{@type} lenght for #{@name} is #{length}, you have #{value.to_s.length}" if value.to_s.length  < length
+    end
+
+    # default max implementation
+    def max(value, length)
+      raise TypeError, "Max #{@type} length for #{@name} is #{length}, you have #{value.to_s.length}" if value.to_s.length  > length
+    end
+
+    # if value is not blank, it is sent to set method
+    def set(value)
+      value
+    end
+
+    # if value is blank?, trigger default
+    # for example set it to false for boolean type and [] for array type
+    def default
+      nil
+    end
+
+    # default validation for any type
+    def validate(what)
+      true
+    end
+
+    ### SAFE TO OVERLOAD: END
+
+    # set options
+    def initialize(opts={})
+      @type = self.class.to_s.split('::')[1].sub('Type','').downcase.to_sym
+      @opts = opts
+      @name = opts.delete(:name)
+    end
+
+    def check_type(type)
+      type_klass = "Typero::#{type.to_s.classify}Type"
+      (type_klass.constantize rescue false) ? true : false
+    end
+
+    def get_value(instance)
+      # get current var value
+      value = instance.respond_to?('[]') ? instance[@name] : instance.instance_variable_get("@#{@name}")
+      if value.blank?
+        # if blank check for default
+        if @opts[:default]
+          @opts[:default].class.to_s == 'Proc' ? @opts[:default].call(instance) : @opts[:default]
+        else
+          return default
+        end
+      else
+        value
+      end
+    end
+
+    def set_value(instance, value=nil)
+      if !value.blank?
+        # for user emails, once defined cant be overitten
+        if @opts[:protected] && get_value(instance) && get_value(instance) != value
+          raise TypeError, @opts[:protected].class == TrueClass ? "#{@name.capitalize} is allready defined and can't be overwritten." : @opts[:protected]
+        end
+
+        value = set(value)
+
+        # search for unique fields on set, say for email
+        # so it is not checked on save, it is checked on set
+        if @opts[:uniq]
+          filter = instance.class.select(:id).where("#{@name}=?", value)
+          filter = filter.where('id<>?', instance.id) if instance.id
+          raise TypeError, @opts[:uniq].class == TrueClass ? "Field #{@name} is uniqe and allready exists" : @opts[:uniq] if filter.first
+        end
+
+        min(value, @opts[:min]) if @opts[:min]
+        max(value, @opts[:max]) if @opts[:max]
+
+        validate(value)
+      elsif @opts[:req]
+        msg = @opts[:req].class == TrueClass ? "is required" : @opts[:req]
+        raise TypeError, msg
+      else
+        value = default
+      end
+
+      if instance.respond_to?('[]')
+        # save to hash by default
+        instance[@name] = value
+      else
+        # fallback to instance variable if no hash (plain class, not AR or Sequel)
+        instance.instance_variable_set("@#{@name}", value)
+      end
+    end
+  end
+end
+
+

data/lib/typero/type/array.rb

@@ -0,0 +1,25 @@
+module Typero
+  class ArrayType < Typero::Type
+    def default
+      []
+    end
+
+    def set(value)
+      value = value.to_s.split(/\s*,\s*/) unless value.class.to_s.index('Array')
+      if type = @opts[:array_type]
+        check_type(type)
+        value.each { |el| Typero.validate!(el, type) }
+      end
+      value
+    end
+
+    def min(value, length)
+      raise TypeError, "Min array lenght is #{length} elements" if value.length  < length
+    end
+
+    def max(value, length)
+      raise TypeError, "Max array lenght is #{length} elements" if value.length  > length
+    end
+  end
+end
+

data/lib/typero/type/boolean.rb

@@ -0,0 +1,13 @@
+module Typero
+  class BooleanType < Typero::Type
+    def default
+      false
+    end
+
+    def set(value)
+      value = false if [0, '0', 'false'].index(value)
+      !!value
+    end
+  end
+end
+

data/lib/typero/type/email.rb

@@ -0,0 +1,16 @@
+module Typero
+  class EmailType < Typero::Type
+    def set(value)
+      value.downcase
+    end
+
+    def validate(value)
+      raise TypeError, 'not having at least 8 characters' unless value.to_s.length > 7
+      raise TypeError, 'missing @' unless value.include?('@')
+      raise TypeError, 'in wrong domain' unless value =~ /\.\w{2,4}$/
+      raise TypeError, 'in wrong format' unless value =~ /^[\w\-\.]+\@[\w\-\.]+$/i
+      true
+    end
+  end
+end
+

data/lib/typero/type/float.rb

@@ -0,0 +1,16 @@
+module Typero
+  class FloatType < Typero::Type
+    def set(value)
+      value.to_f
+    end
+
+    def min(value, length)
+      raise TypeError, "Min #{@type} lenght for #{@name} is #{length}, you have #{value}" if value.to_f  < length
+    end
+
+    def max(value, length)
+      raise TypeError, "Max #{@type} length for #{@name} is #{length}, you have #{value}" if value.to_f  > length
+    end
+  end
+end
+

data/lib/typero/type/hash.rb

@@ -0,0 +1,8 @@
+module Typero
+  class HashType < Typero::Type
+    def default
+      {}
+    end
+  end
+end
+

data/lib/typero/type/integer.rb

@@ -0,0 +1,8 @@
+module Typero
+  class IntegerType < Typero::Type
+    def set(value)
+      value.to_i
+    end
+  end
+end
+

data/lib/typero/type/label.rb

@@ -0,0 +1,13 @@
+module Typero
+  class LabelType < Typero::Type
+    def set(value)
+      value.to_s.gsub(/[^\w\-]/,'')[0,30].downcase
+    end
+
+    def validate(value)
+      raise TypeError, "having unallowed characters" unless value =~ /^[\w\-]+$/
+      true
+    end
+  end
+end
+

data/lib/typero/type/string.rb

@@ -0,0 +1,10 @@
+module Typero
+  class StringType < Typero::Type
+    def set(value)
+      value = value.to_s
+      value = value.downcase if @opts[:downcase]
+      value
+    end
+  end
+end
+

data/lib/typero/type/url.rb

@@ -0,0 +1,9 @@
+module Typero
+  class UrlType < Typero::Type
+    def validate(value)
+      raise TypeError, 'not starting with http' unless value =~ /^https?:\/\/./
+      true
+    end
+  end
+end
+

metadata

@@ -1,23 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.2.1
 platform: ruby
 authors:
 - Dino Reic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-09 00:00:00.000000000 Z
+date: 2016-09-26 00:00:00.000000000 Z
 dependencies: []
 description: Simple and fast ruby type system. Enforce types as Array, Email, Boolean
   for ruby class instances
-email: reic.din@gmail.com
+email: reic.dino@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/typero.rb
+- "./lib/typero.rb"
+- "./lib/typero/hash.rb"
+- "./lib/typero/instance.rb"
+- "./lib/typero/schema.rb"
+- "./lib/typero/type.rb"
+- "./lib/typero/type/array.rb"
+- "./lib/typero/type/boolean.rb"
+- "./lib/typero/type/email.rb"
+- "./lib/typero/type/float.rb"
+- "./lib/typero/type/hash.rb"
+- "./lib/typero/type/integer.rb"
+- "./lib/typero/type/label.rb"
+- "./lib/typero/type/string.rb"
+- "./lib/typero/type/url.rb"
 homepage: http://rubygems.org/dux/typero
 licenses:
 - MIT