typero 0.9.5 → 0.9.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bcd151d7d7b875c6db7aec28c85c3abcf10596a4f596622050d7e18cdb81e9e
-  data.tar.gz: d54b9c76d6587e5872f19deba20febd7430e19022fe869a1360339c8156205d9
+  metadata.gz: cb6ff45894808ab507b69280a5c0789b1a370aadfc8aa9e02a4d246080dd2b7c
+  data.tar.gz: 4e7a1e952d836c72e4bcdb042335e61fcf7b123ab9b9a952f05c7d12f6a12ee5
 SHA512:
-  metadata.gz: 5b639372e86d329ef150809f52f964a459c3faf369a86d219292a2af6b8364ed5c2745079d409944472ec59316cae690e0f1d554cecdeacb625bb5ccf4b39f29
-  data.tar.gz: 0e887a10b853325c7b27f3c90ab57b3c1987d38576e3f1128fb27eb4982d2aaefdbf6e5ded9e80a75c7085c5674686196b13653eed62db853d6d50fe0c15ad39
+  metadata.gz: 45688f02580d891eb335d0eea0fbd56a4572f2571da2859c6dbc29253b848334640c6748ccd4fba3428b2a22309c3ad8ec1d21d2a42bc5da623d70785bc673dc
+  data.tar.gz: cfd0091edbc1b7f30c6fcd3a8ba4e0cb6965b8389405abadaaac1b6b2fa0040fe0c39123d5d74c19c497446f42a40bc4110d4a95f54462867366edd27ee1a55d

data/.version

@@ -1 +1 @@
-0.9.5
+0.9.9

data/lib/adapters/sequel.rb

@@ -2,8 +2,16 @@
 
 module Sequel::Plugins::Typero
   module ClassMethods
-    def typero
-      Typero.schema self
+    def schema name = nil, &block
+      name ||= self
+      name = name.to_s.underscore.singularize
+      value = Typero.schema name, type: :model, &block
+
+      if ENV['DB_MIGRATE'] == 'true' && defined?(AutoMigrate)
+        AutoMigrate.apply_schema self
+      end
+
+      value
     end
   end
 
@@ -12,31 +20,32 @@ module Sequel::Plugins::Typero
     def validate
       super
 
-      schema = Typero.schema(self.class) || return
-
-      schema.validate(self) do |name, err|
-        errors.add(name, err) unless (errors.on(name) || []).include?(err)
-      end
+      # Typero schema check
+      if schema = Typero.schema?(self.class)
+        schema.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
-      schema.rules.each do |field, rule|
-        # check uniqe fields
-        if unique = rule.dig(:meta, :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 = unique.class == TrueClass ? %[Value "#{value}" for field "#{field}" has been already used, please chose another value.] : unique
-            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+        # this are rules unique to database, so we check them here
+        schema.rules.each do |field, rule|
+          # check uniqe fields
+          if unique = rule.dig(:meta, :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 #{respond_to?(:ref) ? :ref : :id}::text<>?" % [field], value, id.to_s).first
+              error = unique.class == TrueClass ? %[Value "#{value}" for field "#{field}" has been already used, please chose another value.] : unique
+              errors.add(field, error) unless (errors.on(field) || []).include?(error)
+            end
           end
-        end
 
-        # check protected fields
-        if prot = rule.dig(:meta, :protected) && self[:id]
-          if column_changed?(field)
-            error = prot.class == TrueClass ? "value once defined can't be overwritten." : prot
-            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          # check protected fields
+          if (prot = rule.dig(:meta, :protected)) && self[:id]
+            if column_changed?(field)
+              error = prot.class == TrueClass ? "value once defined can't be overwritten." : prot
+              errors.add(field, error) unless (errors.on(field) || []).include?(error)
+            end
           end
         end
       end

data/lib/typero/{params.rb → define.rb}

@@ -1,13 +1,33 @@
-# Base class for schema validation
+# Base class for schema validation, this loads and defined schema.
+# Accepts set of params and returns hash of parsed rules
+
+# module Typero
+#   class Loader
+#     def timestamps
+#       created_at Time
+#       created_by_ref
+#     end
+#   end
+# end
+
+# class Task < ApplicationModel
+#   schema do
+#     name           # string type
+#     timestamps     # metod defined -> call
+#   end
+# end
+
+require 'set'
+require 'json'
 
 module Typero
-  class Params
+  class Define
     attr_reader :db_rules
 
-    def initialize &block
+    def initialize rules = nil, &block
       @db_rules = []
-      @rules    = {}
-      instance_exec &block
+      @rules    = rules || {}
+      instance_exec &block if block
     end
 
     def rules
@@ -72,13 +92,13 @@ module Typero
         opts[:default]  = true
         opts[:type]     = :boolean
       elsif opts[:type].is_a?(FalseClass) || opts[:type] == :false || opts[:type] == :boolean
-        opts[:required] = false if opts[:required].nil?
+        opts[:required] = false
         opts[:default]  = false if opts[:default].nil?
         opts[:type]     = :boolean
       end
 
       # model / schema
-      if opts[:type].class.ancestors.include?(Typero::Schema)
+      if opts[:type].is_a?(Typero::Schema)
         opts[:model] = opts.delete(:type)
       end
       opts[:model] = opts.delete(:schema) if opts[:schema]
@@ -89,23 +109,21 @@ module Typero
         opts[:model] = Typero.schema &block
       end
 
-      opts[:type] ||= 'string'
-      opts[:type]   = opts[:type].to_s.downcase.to_sym
+      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
+      # check allowed params, all optional should go in meta
+      type = Typero::Type.load opts[:type]
       opts.keys.each do |key|
-        type = Typero::Type.load opts[:type]
         type.allowed_opt?(key) {|err| raise ArgumentError, err }
       end
 
       field = field.to_sym
 
-      db :add_index, field if opts.delete(:index)
-
-      # trigger error if type not found
-      Typero::Type.load opts[:type]
+      if opts.delete(:index)
+        db :add_index, field
+      end
 
       @rules[field] = opts
     end
@@ -114,16 +132,14 @@ module Typero
     # db :timestamps
     # db :add_index, :code -> t.add_index :code
     def db *args
-      @db_rules.push args
+      @db_rules.push args.unshift(:db_rule!)
     end
 
-    # set :age, type: :integer -> integer :age
-    # email :email
-    #
-    # set :emails, Array[:email]
-    # email Array[:emails]
+    # if method undefine, call set method
+    # age Integer -> set :age, type: :integer
+    # email Array[:emails] -> set :emails, Array[:email]
     def method_missing field, *args, &block
       set field, *args, &block
     end
   end
-end
+end

data/lib/typero/schema.rb

@@ -1,34 +1,90 @@
+# Typero.schema :user, type: :model do
+
+# Typero.schema :some_name, type: :model, db: DB_LOG do
+#   set :name, String, req: true
+#   set :email, :email, req: true
+#   set :emails, [:email], min: 2
+# end
+#
+# rules = Typero.schema :some_name
+#
+# or
+#
+# rules = Typero.schema do
+#   string :name, req: true    # generic email string
+#   email :email, req: true    # string of type email
+#   emails [:skills], min: 2   # list of emails in filed named "emails"
+# end
+#
+# errors = rules.validate (@object || @hash) {|errors| ... }
+# rules.valid? (@object)
+
 module Typero
   class Schema
-    # accepts dsl block to
-    def initialize &block
-      raise "Params not defined" unless block_given?
-      @schema = Params.new &block
+    SCHEMA_STORE ||= {}
+
+    attr_reader :klass
+    attr_reader :schema
+    attr_reader :opts
+
+    # accepts dsl block to define schema
+    # or define: keyword for internal use (only/except)
+    def initialize name, opts = nil, define: nil, &block
+      @opts = opts || {}
+
+      if define
+        @schema = define
+      elsif block
+        @schema = Define.new &block
+
+        if name
+          @klass = name
+          SCHEMA_STORE[name] = self
+        end
+      else
+        raise "Use Typero.schema(:name) to load stored schema"
+      end
+    end
+
+    # returns new schema with only specified keys
+    def only *keys
+      keys = keys.map(&:to_sym)
+      filtered = rules.select { |k, _| keys.include?(k) }
+      self.class.new(nil, define: Define.new(filtered))
+    end
+
+    # returns new schema without specified keys
+    def except *keys
+      keys = keys.map(&:to_sym)
+      filtered = rules.reject { |k, _| keys.include?(k) }
+      self.class.new(nil, define: Define.new(filtered))
     end
 
     # validates any instance object with hash variable interface
-    # it also coarces values
-    def validate object, options=nil
-      @options = options || {}
+    # it also coerces values
+    def validate object, options = nil
       @object  = object
       @errors  = {}
+      options  = options || {}
 
       # remove undefined keys if Hash provided
-      if @options[:strict] && object.is_a?(Hash)
+      if options[:strict] && object.is_a?(Hash)
         undefined = object.keys.map(&:to_s) - @schema.rules.keys.map(&:to_s)
         object.delete_if { |k, _| undefined.include?(k.to_s) }
       end
 
       @schema.rules.each do |field, opts|
-        # force filed as a symbol
+        # force field as a symbol
         field = field.to_sym
 
-        for k in opts.keys
+        opts.keys.each do |k|
           opts[k] = @object.instance_exec(&opts[k]) if opts[k].is_a?(Proc)
         end
 
         # set value to default if value is blank and default given
-        @object[field] = opts[:default] if opts[:default] && @object[field].blank?
+        if !opts[:default].nil? && @object[field].to_s.blank?
+          @object[field] = opts[:default]
+        end
 
         if @object.respond_to?(:key?)
           if @object.key?(field)
@@ -49,7 +105,7 @@ module Typero
 
           value = value
             .flatten
-            .map { |el| el.to_s == '' ? nil : check_filed_value(field, el, opts) }
+            .map { |el| el.to_s == '' ? nil : check_field_value(field, el, opts) }
             .compact
 
           value = Set.new(value).to_a unless opts[:duplicates]
@@ -68,7 +124,7 @@ module Typero
             add_error field, 'Value "%s" is not allowed' % value, opts
           end
 
-          value = check_filed_value field, value, opts
+          value = check_field_value field, value, opts
 
           add_required_error field, value, opts
         end
@@ -92,14 +148,14 @@ module Typero
     # returns field, db_type, db_opts
     def db_schema
       out = @schema.rules.inject([]) do |total, (field, opts)|
-        # get db filed schema
+        # get db field schema
         type, opts  = Typero::Type.load(opts[:type]).new(nil, opts).db_field
 
-        # add array true to field it ont defined in schema
+        # add array true to field if not defined in schema
         schema_opts = @schema.rules[field]
         opts[:array] = true if schema_opts[:array]
 
-        total << [type, field, opts]
+        total << [field, type, opts]
       end
 
       out += @schema.db_rules
@@ -107,7 +163,7 @@ module Typero
       out
     end
 
-    # iterate trough all the ruels via block interface
+    # iterate through all the rules via block interface
     # schema.rules do |field, opts|
     # schema.rules(:url) do |field, opts|
     def rules filter = nil, &block
@@ -146,18 +202,20 @@ module Typero
       add_error field, msg, opts
     end
 
-    def check_filed_value field, value, opts
+    def check_field_value field, value, opts
       klass = "Typero::%sType" % safe_type(opts[:type])
       check = klass.constantize.new value, opts
       check.get
     rescue TypeError => e
       if e.message[0] == '{'
-        for key, msg in JSON.parse(e.message)
+        JSON.parse(e.message).each do |key, msg|
           add_error [field, key].join('.'), msg, opts
         end
       else
         add_error field, e.message, opts
       end
+    rescue JSON::ParserError
+      add_error field, e.message, opts
     end
   end
 end

data/lib/typero/type/type.rb

@@ -5,12 +5,12 @@ module Typero
     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_length_error: 'min length is %s, you have %s',
+        max_length_error: 'max length 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',
-        not_in_range: 'Value in not in allowed range (%s)'
+        not_in_range: 'Value is not in allowed range (%s)'
       }
     }
 
@@ -23,6 +23,8 @@ module Typero
       :default,
       :description,
       :delimiter,
+      :duplicates,
+      :index,
       :max_count,
       :meta,
       :min_count,
@@ -71,12 +73,16 @@ module Typero
 
         false
       end
+
+      def db_schema
+        new(nil).db_schema
+      end
     end
 
     ###
 
     def initialize value, opts={}, &block
-      value = value.strip.rstrip if value.is_a?(String)
+      value = value.strip if value.is_a?(String)
 
       opts.keys.each {|key| self.class.allowed_opt?(key) }
 

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

@@ -8,6 +8,9 @@ class Typero::CurrencyType < Typero::FloatType
 
   def set
     value { |data| data.to_f.round(2) }
+
+    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

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

@@ -2,12 +2,17 @@ class Typero::DateType < Typero::Type
   opts :min, 'Smallest date-time allowed'
   opts :max, 'Maximal date-time allowed'
 
+  error :en, :invalid_date, 'is not a valid date'
   error :en, :min_date, 'Minimal allowed date is %s'
   error :en, :max_date, 'Maximal allowed date is %s'
 
   def set
     unless [Date].include?(value.class)
-      value { |data| DateTime.parse(data) }
+      begin
+        value { |data| DateTime.parse(data.to_s) }
+      rescue Date::Error, ArgumentError
+        error_for(:invalid_date)
+      end
     end
 
     value { |data| DateTime.new(data.year, data.month, data.day) }
@@ -24,12 +29,12 @@ class Typero::DateType < Typero::Type
   def check_date_min_max
     if min = opts[:min]
       min = DateTime.parse(min)
-      error_for(:min_date, min) % min if min > value
+      error_for(:min_date, min) if min > value
     end
 
     if max = opts[:max]
       max = DateTime.parse(max)
-      error_for(:max_date, max) % max if value > max
+      error_for(:max_date, max) if value > max
     end
 
     value

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

@@ -4,16 +4,22 @@ class Typero::DatetimeType < Typero::DateType
   opts :min, 'Smallest date allowed'
   opts :max, 'Maximal date allowed'
 
+  error :en, :invalid_datetime, 'is not a valid datetime'
+
   def set
     unless [Time, DateTime].include?(value.class)
-      value { |data| DateTime.parse(data) }
+      begin
+        value { |data| DateTime.parse(data.to_s) }
+      rescue Date::Error, ArgumentError
+        error_for(:invalid_datetime)
+      end
     end
 
     check_date_min_max
   end
 
   def db_schema
-    [:datetime]
+    [:timestamp]
   end
 end
 

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

@@ -1,6 +1,6 @@
 class Typero::FloatType < Typero::Type
   opts :min, 'Minimum value'
-  opts :max, 'Maximun value'
+  opts :max, 'Maximum value'
   opts :round, 'Round to (decimal spaces)'
 
   def set
@@ -11,14 +11,12 @@ class Typero::FloatType < Typero::Type
       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]
+    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
-    opts = {}
-    opts[:null] = false if opts[:required]
-    [:float, opts]
+    [:float, {}]
   end
 end
 

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

@@ -3,11 +3,11 @@ class Typero::HashType < Typero::Type
 
   def set
     if value.is_a?(String) && value[0,1] == '{'
-      @value = JSON.load(value)
+      @value = JSON.parse(value)
     end
 
     @value ||= {}
-    @value.delete_if {|_, v| v.empty? }
+    @value.delete_if {|_, v| v.respond_to?(:empty?) && v.empty? }
 
     error_for(:not_hash_type_error) unless @value.respond_to?(:keys) && @value.respond_to?(:values)
 

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

@@ -10,7 +10,9 @@ class Typero::ImageType < Typero::Type
     error_for(:image_not_starting_error) unless value =~ /^https?:\/\/./
 
     if opts[:strict]
-      ext = value.split('.').last.downcase
+      # strip query string and fragment before checking extension
+      path = value.split('?').first.split('#').first
+      ext = path.split('.').last.downcase
       error_for(:image_not_image_format) unless FORMATS.include?(ext)
     end
   end

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

@@ -1,6 +1,6 @@
 class Typero::IntegerType < Typero::Type
   opts :min, 'Minimum value'
-  opts :max, 'Maximun value'
+  opts :max, 'Maximum value'
 
   def set
     value(&:to_i)

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

@@ -10,7 +10,7 @@ class Typero::ModelType < Typero::Type
       errors[field] = error
     end
 
-    @value.delete_if {|_, v| v.empty? }
+    @value.delete_if {|_, v| v.respond_to?(:empty?) && v.empty? }
 
     raise TypeError.new errors.to_json if errors.keys.first
   end

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

@@ -3,7 +3,7 @@ class Typero::OibType < Typero::Type
 
   def set
     value do |data|
-      check?(data) ? data.to_i : error_for(:not_an_oib_error)
+      check?(data) ? data.to_s : error_for(:not_an_oib_error)
     end
   end
 

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

@@ -14,7 +14,7 @@ class Typero::PointType < Typero::Type
       value { 'SRID=4326;POINT(%s)' % point }
     end
 
-    if value && value.include?(',') && !value =~ /^SRID=4326;POINT\(/
+    if value && value.include?(',') && value !~ /^SRID=4326;POINT\(/
       error_for(:unallowed_characters_error)
     end
   end

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

@@ -11,6 +11,8 @@ class Typero::SimplePointType < Typero::Type
     if !value.include?('POINT') && value.include?(',')
       value { value.split(/\s*,\s*/)[0,2] }
     end
+
+    # value { value.map { sprintf("%.16f", _1).to_f } }
   end
 
   def db_schema

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

@@ -1,6 +1,6 @@
 class Typero::StringType < Typero::Type
-  opts :min, 'Minimun string length'
-  opts :max, 'Maximun string length'
+  opts :min, 'Minimum string length'
+  opts :max, 'Maximum string length'
   opts :downcase, 'is the string in downcase?'
 
   def set

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

@@ -1,8 +1,16 @@
 require_relative 'string_type'
 
 class Typero::TextType < Typero::StringType
-  opts :min, 'Minimun string length'
-  opts :max, 'Maximun string length'
+  opts :min, 'Minimum string length'
+  opts :max, 'Maximum string length'
+
+  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
     [:text, {}]

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

@@ -2,8 +2,7 @@ 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]
+    error_for(:url_not_starting_error) unless value =~ /^https?:\/\//
   end
 
   def db_schema

data/lib/typero/typero.rb

@@ -1,26 +1,9 @@
-# rules = Typero.schema do
-#   set :name, String, req: true
-#   set :email, :email, req: true
-#   set :skills, [:email], min: 2
-# end
-#
-# or
-#
-# rules = Typero.schema do
-#   string :name, req: true
-#   email :email, req: true
-#   email [:skills], min: 2
-# end
-#
-# errors = rules.validate @object
-# rules.valid?
-# rules.validate(@object) { |errors| ... }
+# module quick access to other types
 
 module Typero
   extend self
 
   VERSION ||= File.read File.expand_path "../../.version", File.dirname(__FILE__)
-  SCHEMAS ||= {}
 
   # check and coerce value
   # Typero.type(:label) -> Typero::LabelType
@@ -55,70 +38,49 @@ module Typero
   # get schema
   # Typero.schema(:blog)
 
-  # get schema with options (as array)
-  # Typero.schema(:blog, :with_schema)
-
-  # get all schema names with type: model
+  # get all schema that matches any option
   # Typero.schema(type: :model)
   def schema name = nil, opts = nil, &block
     klass = name.to_s.classify if name && !name.is_a?(Hash)
 
     if block_given?
-      Typero::Schema.new(&block).tap do |schema|
-        if klass
-          SCHEMAS[klass] = [schema, opts || {}]
-        end
-      end
+      # Typero.schema type: :model, db: DB_LOG do
+      Typero::Schema.new(klass, opts, &block)
     else
-      # Schema not given, get schema
       if name.is_a?(Hash)
-        # Typero.schema type: :model
+        # Schema not given, get schema
+        #   Typero.schema type: :model
         out = []
 
-        for key, _ in SCHEMAS
-          schema, opts = _
-          next unless opts[name.keys.first] == name.values.first
-          out.push key.classify
+        Schema::SCHEMA_STORE.values.each do |schema|
+          if schema.opts[name.keys.first] == name.values.first
+            out.push schema.klass
+          end
         end
 
         out
-      elsif klass
-        # Typero.schema :user
-        schema   = SCHEMAS[klass]
-        schema ||= class_finder klass, :schema
-
-        if opts
-          schema
-        else
-          schema.respond_to?(:[]) ? schema[0] : schema
-        end
       else
-        raise ArgumentError, 'Schema type not defined.'
+        # Typero.schema :user
+        Typero::Schema::SCHEMA_STORE[klass] || raise('Schema "%s" not found' % klass)
       end
     end
   end
 
+  # same as schema but returns nil if not found
+  def schema? name
+    klass = name.to_s.classify if name
+    Typero::Schema::SCHEMA_STORE[klass] if klass
+  end
+
+  # get array of database fields, ruby Sequel compatibile
+  def db_schema name
+    Typero.schema(name).db_schema
+  end
+
   def defined? name
     Typero::Type.load name
     true
   rescue ArgumentError
     false
   end
-
-  private
-
-  # class_finder :user, :exporter, :representer
-  # find first UserExporter, User::Exporter, User::Representer, UserRepresenter
-  def class_finder *args
-    name = args.shift.to_s.classify
-
-    for el in args
-      for separator in ['_','/']
-        klass = [name, el].join(separator).classify
-        return klass.constantize if const_defined? klass
-      end
-    end
-
-    nil
-  end
 end

data/lib/typero.rb

@@ -3,7 +3,7 @@
 # base libs
 require_relative 'typero/typero'
 require_relative 'typero/schema'
-require_relative 'typero/params'
+require_relative 'typero/define'
 require_relative 'typero/type/type'
 
 # checker types

metadata

@@ -1,29 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: typero
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.9
 platform: ruby
 authors:
 - Dino Reic
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-20 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: fast_blank
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 1980-01-02 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.dino@gmail.com
@@ -34,7 +19,7 @@ files:
 - "./.version"
 - "./lib/adapters/sequel.rb"
 - "./lib/typero.rb"
-- "./lib/typero/params.rb"
+- "./lib/typero/define.rb"
 - "./lib/typero/schema.rb"
 - "./lib/typero/type/type.rb"
 - "./lib/typero/type/types/boolean_type.rb"
@@ -62,7 +47,6 @@ homepage: https://github.com/dux/typero
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -77,8 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby type system
 test_files: []